geny-executor 2.44.0__tar.gz → 2.45.0__tar.gz

{geny_executor-2.44.0 → geny_executor-2.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.44.0
+Version: 2.45.0
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.44.0 → geny_executor-2.45.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.44.0"
+version = "2.45.0"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "Apache-2.0"

{geny_executor-2.44.0 → geny_executor-2.45.0}/src/geny_executor/llm_client/claude_code.py

@@ -32,6 +32,7 @@ tool dispatch — see ``stages/s10_tool``.
 
 from __future__ import annotations
 
+from dataclasses import replace
 import logging
 import os
 from contextlib import aclosing
@@ -56,6 +57,7 @@ from geny_executor.llm_client.translators._cli import (
     StreamJsonAccumulator,
     assemble_response_from_stream_json,
     build_stream_json_stdin,
+    messages_have_images,
     claude_code_argv,
     parse_json_output_to_response,
 )
@@ -438,6 +440,16 @@ class ClaudeCodeCLIClient(BaseClient):
         except CLIBinaryNotFound as e:
             raise APIError(str(e), category=ErrorCategory.CLI_NOT_FOUND) from e
 
+        # Vision on the non-streaming surface: the ``--print`` positional
+        # prompt is text-only, so a request that carries image blocks must
+        # travel over the stream-json wire (which ingests base64 images
+        # natively). ``create_message`` still returns one assembled
+        # APIResponse — only the wire mode changes. Without this, every
+        # non-stream vision call (e.g. screen-observation captioning) lost
+        # its image and the model answered "I don't see an image".
+        if not request.stream and messages_have_images(request.messages):
+            request = replace(request, stream=True)
+
         cli_version = await self._ensure_cli_version()
         argv = self._build_argv(request)
         stdin = build_stream_json_stdin(request.messages) if request.stream else None

{geny_executor-2.44.0 → geny_executor-2.45.0}/src/geny_executor/llm_client/translators/_cli.py

@@ -262,6 +262,30 @@ def claude_code_argv(
 # ---------------------------------------------------------------------------
 
 
+def messages_have_images(messages: List[Dict[str, Any]]) -> bool:
+    """True when any message carries an Anthropic-style image block.
+
+    Used by the client to decide the wire mode: the ``--print`` positional
+    prompt is text-only, so requests with images must travel as stream-json
+    stdin (the CLI ingests base64 image blocks there)."""
+    for m in messages:
+        content = m.get("content")
+        if isinstance(content, list) and any(
+            isinstance(b, dict) and b.get("type") == "image" for b in content
+        ):
+            return True
+    return False
+
+
+def _image_blocks_of(content: Any) -> List[Dict[str, Any]]:
+    """Anthropic-style image blocks contained in one message's content."""
+    if not isinstance(content, list):
+        return []
+    return [
+        b for b in content if isinstance(b, dict) and b.get("type") == "image"
+    ]
+
+
 def _render_block_for_history(block: Any) -> str:
     """Render one Anthropic-style content block as readable text.
 
@@ -439,9 +463,27 @@ def build_stream_json_stdin(messages: List[Dict[str, Any]]) -> bytes:
         )
 
     flat = (preamble + current_input).strip()
+
+    # The CURRENT turn's images must reach the model as real content blocks —
+    # the CLI's stream-json input ingests base64 image blocks natively, and
+    # flattening them to "[image attachment]" silently blinded every
+    # multi-turn CLI session to chat images and screen-observation frames.
+    # Older turns keep the text placeholder (replaying stale frames would
+    # bloat every request for no recall value).
+    current_images = (
+        _image_blocks_of(messages[last_user_idx].get("content"))
+        if last_user_idx >= 0
+        else []
+    )
+    content: Any
+    if current_images:
+        content = [*current_images, {"type": "text", "text": flat}]
+    else:
+        content = flat
+
     envelope = {
         "type": "user",
-        "message": {"role": "user", "content": flat},
+        "message": {"role": "user", "content": content},
     }
     return (json.dumps(envelope, ensure_ascii=False) + "\n").encode("utf-8")
 

geny_executor-2.45.0/tests/unit/test_claude_code_vision_wire.py

@@ -0,0 +1,226 @@
+"""CLI vision wire (2.45.0): image blocks must actually reach the model.
+
+Two regressions this locks down:
+
+* Non-streaming ``create_message`` built a text-only ``--print`` positional
+  prompt, so every vision call (screen-observation captioning, whiteboard
+  describe) lost its image and the model answered "I don't see an image…".
+  Requests carrying image blocks now switch to the stream-json wire, which
+  ingests base64 images natively (verified against claude CLI 2.1.185).
+
+* Multi-turn ``build_stream_json_stdin`` flattened the CURRENT turn's
+  content through the history renderer, turning image blocks into the
+  literal text ``[image attachment]`` — silently blinding every multi-turn
+  CLI session (the persona) to chat images and screen frames. The last
+  user message's images now ride along as real content blocks.
+"""
+import json
+
+import pytest
+
+from geny_executor.llm_client.base import APIRequest
+from geny_executor.llm_client.claude_code import ClaudeCodeCLIClient
+from geny_executor.llm_client.translators._cli import (
+    build_stream_json_stdin,
+    messages_have_images,
+)
+
+
+def _img(data: str = "AAAA") -> dict:
+    return {
+        "type": "image",
+        "source": {"type": "base64", "media_type": "image/png", "data": data},
+    }
+
+
+def _txt(text: str) -> dict:
+    return {"type": "text", "text": text}
+
+
+# ── messages_have_images ─────────────────────────────────────────────
+
+
+def test_messages_have_images_detects_blocks():
+    assert messages_have_images([{"role": "user", "content": [_img(), _txt("hi")]}])
+
+
+def test_messages_have_images_false_for_text():
+    assert not messages_have_images([{"role": "user", "content": "hello"}])
+    assert not messages_have_images([{"role": "user", "content": [_txt("hi")]}])
+
+
+# ── build_stream_json_stdin: current-turn image preservation ─────────
+
+
+def _envelope(messages) -> dict:
+    return json.loads(build_stream_json_stdin(messages).decode("utf-8"))
+
+
+def test_single_turn_passthrough_keeps_blocks():
+    env = _envelope([{"role": "user", "content": [_img("XYZ"), _txt("color?")]}])
+    types = [b["type"] for b in env["message"]["content"]]
+    assert types == ["image", "text"]
+    assert env["message"]["content"][0]["source"]["data"] == "XYZ"
+
+
+def test_multi_turn_keeps_last_user_images_as_blocks():
+    env = _envelope(
+        [
+            {"role": "user", "content": "first question"},
+            {"role": "assistant", "content": "answer"},
+            {"role": "user", "content": [_img("CURRENT"), _txt("what is on screen?")]},
+        ]
+    )
+    content = env["message"]["content"]
+    assert isinstance(content, list)
+    images = [b for b in content if b["type"] == "image"]
+    assert len(images) == 1
+    assert images[0]["source"]["data"] == "CURRENT"
+    # Flattened history rides in the text block alongside the image.
+    text = "\n".join(b["text"] for b in content if b["type"] == "text")
+    assert "### Assistant" in text
+    assert "what is on screen?" in text
+
+
+def test_multi_turn_older_images_stay_placeholders():
+    env = _envelope(
+        [
+            {"role": "user", "content": [_img("OLD"), _txt("earlier frame")]},
+            {"role": "assistant", "content": "noted"},
+            {"role": "user", "content": "text only now"},
+        ]
+    )
+    content = env["message"]["content"]
+    # No image in the last user turn → plain flattened string, with the old
+    # frame reduced to its placeholder.
+    assert isinstance(content, str)
+    assert "OLD" not in content
+    assert "[image attachment]" in content
+
+
+def test_multi_turn_text_only_unchanged():
+    env = _envelope(
+        [
+            {"role": "user", "content": "a"},
+            {"role": "assistant", "content": "b"},
+            {"role": "user", "content": "c"},
+        ]
+    )
+    assert isinstance(env["message"]["content"], str)
+
+
+# ── client: non-stream + images → stream-json wire ───────────────────
+
+
+class _CaptureRunner:
+    """Stub runner recording the wire mode ``_send`` chose."""
+
+    def __init__(self):
+        self.argv = None
+        self.stdin = b""
+        self.streamed = False
+
+    async def run_oneshot(self, argv, stdin=None):  # pragma: no cover - guard
+        self.argv = argv
+        raise AssertionError("image request must not use the one-shot wire")
+
+    def stream(self, argv, stdin_iter=None):
+        self.argv = argv
+        self.streamed = True
+
+        async def _gen():
+            if stdin_iter is not None:
+                async for chunk in stdin_iter:
+                    self.stdin += chunk
+            assistant = {
+                "type": "assistant",
+                "message": {
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": "A red square."}],
+                },
+                "session_id": "s",
+            }
+            done = {
+                "type": "result",
+                "subtype": "success",
+                "is_error": False,
+                "result": "A red square.",
+                "session_id": "s",
+                "usage": {"input_tokens": 1, "output_tokens": 1},
+            }
+            yield (json.dumps(assistant) + "\n").encode("utf-8")
+            yield (json.dumps(done) + "\n").encode("utf-8")
+
+        return _gen()
+
+
+@pytest.mark.asyncio
+async def test_nonstream_image_request_rides_stream_wire(monkeypatch):
+    client = ClaudeCodeCLIClient(binary_path="/bin/true", api_key="sk-test")
+    runner = _CaptureRunner()
+    monkeypatch.setattr(client, "_make_runner", lambda: runner)
+
+    async def _ver():
+        return "test"
+
+    monkeypatch.setattr(client, "_ensure_cli_version", _ver)
+
+    request = APIRequest(
+        model="claude-haiku-4-5-20251001",
+        messages=[{"role": "user", "content": [_img("PIXELS"), _txt("describe")]}],
+        stream=False,
+    )
+    response = await client._send(request)
+
+    assert runner.streamed, "non-stream vision call must switch to stream-json"
+    assert "--input-format" in runner.argv
+    assert "PIXELS" in runner.stdin.decode("utf-8")
+    assert response.text == "A red square."
+
+
+@pytest.mark.asyncio
+async def test_nonstream_text_request_keeps_oneshot_wire(monkeypatch):
+    client = ClaudeCodeCLIClient(binary_path="/bin/true", api_key="sk-test")
+
+    class _OneshotRunner:
+        def __init__(self):
+            self.argv = None
+
+        async def run_oneshot(self, argv, stdin=None):
+            self.argv = argv
+
+            class _R:
+                returncode = 0
+                stdout = json.dumps(
+                    {
+                        "type": "result",
+                        "subtype": "success",
+                        "is_error": False,
+                        "result": "ok",
+                        "session_id": "s",
+                        "usage": {"input_tokens": 1, "output_tokens": 1},
+                    }
+                ).encode("utf-8")
+                stderr = b""
+
+            return _R()
+
+        def stream(self, argv, stdin_iter=None):  # pragma: no cover - guard
+            raise AssertionError("text-only non-stream must stay one-shot")
+
+    runner = _OneshotRunner()
+    monkeypatch.setattr(client, "_make_runner", lambda: runner)
+
+    async def _ver():
+        return "test"
+
+    monkeypatch.setattr(client, "_ensure_cli_version", _ver)
+
+    request = APIRequest(
+        model="claude-haiku-4-5-20251001",
+        messages=[{"role": "user", "content": "say ok"}],
+        stream=False,
+    )
+    response = await client._send(request)
+    assert response.text == "ok"
+    assert "--output-format" in runner.argv