flowent 0.0.7 → 0.0.10

package/backend/tests/integration/api/test_nodes_api.py

@@ -1,787 +0,0 @@
-import os
-import threading
-import time
-from uuid import UUID
-
-from fastapi.testclient import TestClient
-
-from flowent.models import (
-    AgentState,
-    AssistantText,
-    ErrorEntry,
-    ImagePart,
-    LLMResponse,
-    ReceivedMessage,
-    TextPart,
-)
-from flowent.providers.errors import LLMProviderError
-from flowent.registry import registry
-from flowent.settings import STEWARD_ROLE_INCLUDED_TOOLS
-from flowent.tools import MINIMUM_TOOLS
-
-_ONE_PIXEL_PNG = bytes.fromhex(
-    "89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c489"
-    "0000000d49444154789c6360000002000154a24f5d0000000049454e44ae426082"
-)
-
-
-def _get_assistant_id(client: TestClient) -> str:
-    response = client.get("/api/assistant")
-
-    assert response.status_code == 200
-    assistant_id = response.json()["id"]
-    UUID(assistant_id)
-    return assistant_id
-
-
-def test_health_check(client: TestClient):
-    response = client.get("/health")
-
-    assert response.status_code == 200
-    assert response.json() == {"status": "healthy"}
-
-
-def test_list_agents(client: TestClient):
-    response = client.get("/api/nodes")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert "nodes" in data
-    assert isinstance(data["nodes"], list)
-
-
-def test_get_agent_not_found(client: TestClient):
-    response = client.get("/api/nodes/non-existent-id")
-
-    assert response.status_code == 404
-    assert "Node not found" in response.json()["detail"]
-
-
-def test_get_node_detail_includes_runtime_config(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    response = client.get(f"/api/nodes/{assistant_id}")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["id"] == assistant_id
-    assert isinstance(data["contacts"], list)
-    assert isinstance(data["history"], list)
-    assert isinstance(data["tools"], list)
-    assert isinstance(data["write_dirs"], list)
-    assert isinstance(data["allow_network"], bool)
-    assert data["workflow_permissions"] == {
-        "allow_network": data["allow_network"],
-        "write_dirs": data["write_dirs"],
-    }
-
-
-def test_worker_contacts_follow_output_paths(
-    client: TestClient,
-):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution", "allow_network": True, "write_dirs": ["/tmp"]},
-    ).json()
-    worker = client.post(
-        f"/api/workflows/{tab['id']}/nodes",
-        json={"role_name": "Worker", "name": "Worker"},
-    ).json()
-    reviewer = client.post(
-        f"/api/workflows/{tab['id']}/nodes",
-        json={"role_name": "Worker", "name": "Reviewer"},
-    ).json()
-
-    detail_without_edge = client.get(f"/api/nodes/{worker['id']}")
-
-    assert detail_without_edge.status_code == 200
-    worker_detail = detail_without_edge.json()
-    assert worker_detail["contacts"] == []
-    assert worker_detail["allow_network"] is True
-    assert worker_detail["write_dirs"] == ["/tmp"]
-    assert worker_detail["workflow_permissions"] == {
-        "allow_network": True,
-        "write_dirs": ["/tmp"],
-    }
-    leader_without_edge = client.get(f"/api/nodes/{tab['leader_id']}")
-    assert leader_without_edge.status_code == 200
-    assert any(
-        contact["id"] == worker["id"]
-        for contact in leader_without_edge.json()["contacts"]
-    )
-
-    edge_response = client.post(
-        f"/api/workflows/{tab['id']}/edges",
-        json={
-            "from_node_id": worker["id"],
-            "to_node_id": reviewer["id"],
-        },
-    )
-
-    assert edge_response.status_code == 200
-    edge = edge_response.json()
-    worker_with_edge = client.get(f"/api/nodes/{worker['id']}").json()
-    assert worker_with_edge["contacts"] == [
-        {
-            "id": reviewer["id"],
-            "target_id": reviewer["id"],
-            "node_type": "agent",
-            "role_name": "Worker",
-            "name": "Reviewer",
-            "state": "idle",
-            "is_leader": False,
-            "from_output_port_key": "out",
-            "to_input_port_key": "in",
-            "port_type": "parts",
-            "edge_id": edge["id"],
-        }
-    ]
-
-
-def test_only_assistant_node_exists_at_startup(client: TestClient):
-    list_response = client.get("/api/nodes")
-
-    assert list_response.status_code == 200
-    nodes = list_response.json()["nodes"]
-    assert len(nodes) == 1
-    UUID(nodes[0]["id"])
-    assert nodes[0]["node_type"] == "assistant"
-    assert nodes[0]["name"] == "Assistant"
-    assert nodes[0]["role_name"] == "Steward"
-
-
-def test_get_assistant_detail_includes_tools_and_permissions(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    response = client.get(f"/api/nodes/{assistant_id}")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["id"] == assistant_id
-    assert set(data["tools"]) == set(MINIMUM_TOOLS) | set(STEWARD_ROLE_INCLUDED_TOOLS)
-    assert data["write_dirs"] == [os.getcwd()]
-    assert data["allow_network"] is True
-    assert data["workflow_permissions"] == {
-        "allow_network": True,
-        "write_dirs": [os.getcwd()],
-    }
-
-
-def test_get_node_detail_keeps_state_out_of_history(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    assistant = registry.get(assistant_id)
-    assert assistant is not None
-    assistant.set_state(AgentState.RUNNING, "processing")
-
-    response = client.get(f"/api/nodes/{assistant_id}")
-
-    assert response.status_code == 200
-    data = response.json()
-    assert data["state"] == "running"
-    assert all(entry["type"] != "StateEntry" for entry in data["history"])
-
-
-def test_assistant_cannot_be_terminated_via_nodes_api(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    response = client.post(f"/api/nodes/{assistant_id}/terminate")
-
-    assert response.status_code == 400
-    assert response.json() == {"detail": "Cannot terminate assistant"}
-
-
-def test_tab_leader_cannot_be_terminated_directly(client: TestClient):
-    created_tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-
-    response = client.post(f"/api/nodes/{created_tab['leader_id']}/terminate")
-
-    assert response.status_code == 400
-    assert response.json() == {"detail": "Cannot terminate a workflow Leader directly"}
-
-
-def test_assistant_retry_is_not_available_via_nodes_api(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-
-    response = client.post(f"/api/nodes/{assistant_id}/messages/msg-1/retry")
-
-    assert response.status_code == 400
-    assert response.json() == {
-        "detail": "Use /api/assistant/messages/{message_id}/retry for Assistant retry"
-    }
-
-
-def test_assistant_can_be_interrupted_via_nodes_api_when_running(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    assistant = registry.get(assistant_id)
-    assert assistant is not None
-    assistant.set_state(AgentState.RUNNING, "processing")
-
-    response = client.post(f"/api/nodes/{assistant_id}/interrupt")
-
-    assert response.status_code == 200
-    assert response.json() == {"status": "interrupting"}
-    assert assistant._interrupt_requested.is_set()
-
-
-def test_assistant_can_be_interrupted_via_nodes_api_when_sleeping(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    assistant = registry.get(assistant_id)
-    assert assistant is not None
-    assistant.set_state(AgentState.SLEEPING, "waiting for reply")
-
-    response = client.post(f"/api/nodes/{assistant_id}/interrupt")
-
-    assert response.status_code == 200
-    assert response.json() == {"status": "interrupting"}
-    assert assistant._interrupt_requested.is_set()
-
-
-def test_interrupt_ignores_idle_node(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    response = client.post(f"/api/nodes/{assistant_id}/interrupt")
-
-    assert response.status_code == 200
-    assert response.json() == {"status": "ignored"}
-
-
-def test_assistant_chat_can_be_cleared_via_nodes_api(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    assistant = registry.get(assistant_id)
-    assert assistant is not None
-    assistant.history.append(ReceivedMessage(content="Old message", from_id="human"))
-    assistant.history.append(AssistantText(content="Old reply"))
-
-    response = client.post(f"/api/nodes/{assistant_id}/clear-chat")
-
-    assert response.status_code == 200
-    assert response.json() == {"status": "cleared"}
-
-    detail = client.get(f"/api/nodes/{assistant_id}").json()
-    assert not any(
-        entry["type"] in {"ReceivedMessage", "AssistantText"}
-        for entry in detail["history"]
-    )
-
-
-def test_unknown_slash_input_can_be_sent_directly_to_workflow_leader(
-    client: TestClient,
-):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution", "allow_network": True},
-    ).json()
-
-    response = client.post(
-        f"/api/nodes/{tab['leader_id']}/messages",
-        json={"content": "/unknown investigate the failure"},
-    )
-
-    assert response.status_code == 200
-    message_id = response.json()["message_id"]
-    assert isinstance(message_id, str)
-
-    history = []
-    for _ in range(20):
-        detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
-        history = detail["history"]
-        if any(
-            entry["type"] == "ReceivedMessage"
-            and entry["from_id"] == "human"
-            and entry["message_id"] == message_id
-            and entry["content"] == "/unknown investigate the failure"
-            for entry in history
-        ):
-            break
-        time.sleep(0.01)
-
-    assert any(
-        entry["type"] == "ReceivedMessage"
-        and entry["from_id"] == "human"
-        and entry["message_id"] == message_id
-        and entry["content"] == "/unknown investigate the failure"
-        for entry in history
-    )
-
-
-def test_leader_accepts_new_message_after_error(monkeypatch, client: TestClient):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution", "allow_network": True},
-    ).json()
-    leader = registry.get(tab["leader_id"])
-    assert leader is not None
-    chat_started = threading.Event()
-    release_chat = threading.Event()
-
-    def fake_chat(**kwargs):
-        chat_started.set()
-        release_chat.wait(timeout=2)
-        raise LLMProviderError(
-            "LLM API error\nDetail: still invalid",
-            transient=False,
-        )
-
-    monkeypatch.setattr("flowent.agent.gateway.chat", fake_chat)
-    leader.history.append(ErrorEntry(content="LLM API error\nDetail: Invalid key"))
-    leader.set_state(AgentState.ERROR, "LLM API error")
-
-    try:
-        response = client.post(
-            f"/api/nodes/{tab['leader_id']}/messages",
-            json={"content": "Continue the workflow chat"},
-        )
-
-        assert response.status_code == 200
-        message_id = response.json()["message_id"]
-        assert isinstance(message_id, str)
-        assert chat_started.wait(timeout=1)
-
-        detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
-        history = detail["history"]
-        assert any(
-            entry["type"] == "ErrorEntry"
-            and entry["content"] == "LLM API error\nDetail: Invalid key"
-            for entry in history
-        )
-        assert any(
-            entry["type"] == "ReceivedMessage"
-            and entry["from_id"] == "human"
-            and entry["message_id"] == message_id
-            and entry["content"] == "Continue the workflow chat"
-            for entry in history
-        )
-        assert registry.get(tab["leader_id"]).state == AgentState.RUNNING
-    finally:
-        release_chat.set()
-
-
-def test_leader_rejects_message_when_terminated(client: TestClient):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    leader = registry.get(tab["leader_id"])
-    assert leader is not None
-    leader.set_state(AgentState.TERMINATED, "done")
-
-    response = client.post(
-        f"/api/nodes/{tab['leader_id']}/messages",
-        json={"content": "Continue the workflow chat"},
-    )
-
-    assert response.status_code == 409
-    assert response.json()["detail"] == "This workflow chat is no longer available"
-
-
-def test_leader_help_command_returns_visible_command_feedback(client: TestClient):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-
-    response = client.post(
-        f"/api/nodes/{tab['leader_id']}/messages",
-        json={"content": "/help"},
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "status": "command_executed",
-        "command_name": "/help",
-    }
-
-    detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
-
-    assert any(
-        entry["type"] == "CommandResultEntry"
-        and entry["command_name"] == "/help"
-        and "Available commands" in entry["content"]
-        and "/compact" in entry["content"]
-        for entry in detail["history"]
-    )
-    assert not any(
-        entry["type"] == "ReceivedMessage" and entry.get("content") == "/help"
-        for entry in detail["history"]
-    )
-
-
-def test_leader_clear_command_clears_only_workflow_chat(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    assistant = registry.get(assistant_id)
-    assert assistant is not None
-    assistant.history.append(
-        ReceivedMessage(content="Assistant stays", from_id="human")
-    )
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    worker = client.post(
-        f"/api/workflows/{tab['id']}/nodes",
-        json={"role_name": "Worker", "name": "Worker"},
-    ).json()
-    leader = registry.get(tab["leader_id"])
-    assert leader is not None
-    leader.history.append(ReceivedMessage(content="Old workflow chat", from_id="human"))
-    leader.history.append(AssistantText(content="Old workflow reply"))
-
-    response = client.post(
-        f"/api/nodes/{tab['leader_id']}/messages",
-        json={"content": "/clear"},
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "status": "command_executed",
-        "command_name": "/clear",
-    }
-
-    leader_detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
-    assistant_detail = client.get(f"/api/nodes/{assistant_id}").json()
-    workflow = client.get(f"/api/workflows/{tab['id']}").json()
-
-    assert not any(
-        entry["type"] in {"ReceivedMessage", "AssistantText"}
-        and entry.get("content") in {"Old workflow chat", "Old workflow reply"}
-        for entry in leader_detail["history"]
-    )
-    assert not any(
-        entry["type"] == "CommandResultEntry" and entry["command_name"] == "/clear"
-        for entry in leader_detail["history"]
-    )
-    assert any(
-        entry["type"] == "ReceivedMessage" and entry.get("content") == "Assistant stays"
-        for entry in assistant_detail["history"]
-    )
-    assert any(node["id"] == worker["id"] for node in workflow["nodes"])
-
-
-def test_leader_compact_command_keeps_history_and_adds_system_feedback(
-    monkeypatch,
-    client: TestClient,
-):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution", "allow_network": True},
-    ).json()
-    leader = registry.get(tab["leader_id"])
-    assert leader is not None
-    leader.history.extend(
-        [
-            ReceivedMessage(content="Need a concise recap", from_id="human"),
-            AssistantText(content="I will summarize the workflow."),
-        ]
-    )
-
-    monkeypatch.setattr(
-        "flowent.agent.gateway.chat",
-        lambda *args, **kwargs: LLMResponse(
-            content=(
-                "## Current Goal\nShip the shared commands.\n\n"
-                "## Active Task Boundary\nKeep it in the workflow chat.\n\n"
-                "## Key Constraints\nDo not clear visible history.\n\n"
-                "## Confirmed Decisions\nUse shared commands.\n\n"
-                "## Open Questions\nNone.\n\n"
-                "## Next Actions\nVerify the workflow panel."
-            )
-        ),
-    )
-
-    response = client.post(
-        f"/api/nodes/{tab['leader_id']}/messages",
-        json={"content": "/compact workflow command rollout"},
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "status": "command_executed",
-        "command_name": "/compact",
-    }
-
-    detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
-
-    assert any(
-        entry["type"] == "ReceivedMessage"
-        and entry.get("content") == "Need a concise recap"
-        for entry in detail["history"]
-    )
-    assert any(
-        entry["type"] == "AssistantText"
-        and entry.get("content") == "I will summarize the workflow."
-        for entry in detail["history"]
-    )
-    assert any(
-        entry["type"] == "CommandResultEntry"
-        and entry["command_name"] == "/compact"
-        and entry.get("include_in_context") is False
-        and "Compacted this chat for future replies." in entry["content"]
-        and "Focus: workflow command rollout" in entry["content"]
-        for entry in detail["history"]
-    )
-
-
-def test_leader_image_message_bypasses_conversation_commands(
-    client: TestClient,
-    monkeypatch,
-):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    leader = registry.get(tab["leader_id"])
-    assert leader is not None
-    monkeypatch.setattr(leader, "supports_input_image", lambda: True)
-
-    upload_response = client.post(
-        "/api/image-assets",
-        files={"file": ("pixel.png", _ONE_PIXEL_PNG, "image/png")},
-    )
-    assert upload_response.status_code == 200
-    asset_id = upload_response.json()["id"]
-
-    response = client.post(
-        f"/api/nodes/{tab['leader_id']}/messages",
-        json={
-            "parts": [
-                {"type": "text", "text": "/help"},
-                {
-                    "type": "image",
-                    "asset_id": asset_id,
-                    "mime_type": "image/png",
-                    "width": 1,
-                    "height": 1,
-                },
-            ]
-        },
-    )
-
-    assert response.status_code == 200
-    assert response.json()["status"] == "sent"
-
-    detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
-
-    assert any(
-        entry["type"] == "ReceivedMessage"
-        and entry["from_id"] == "human"
-        and entry["content"] == "/help[image]"
-        for entry in detail["history"]
-    )
-    assert not any(
-        entry["type"] == "CommandResultEntry" and entry["command_name"] == "/help"
-        for entry in detail["history"]
-    )
-
-
-def test_leader_retry_rewrites_tail_and_reuses_image_parts(monkeypatch, client):
-    assistant_id = _get_assistant_id(client)
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    leader = registry.get(tab["leader_id"])
-    assert leader is not None
-    queued_messages = []
-
-    upload_response = client.post(
-        "/api/image-assets",
-        files={"file": ("pixel.png", _ONE_PIXEL_PNG, "image/png")},
-    )
-    assert upload_response.status_code == 200
-    asset_id = upload_response.json()["id"]
-
-    leader.history.extend(
-        [
-            ReceivedMessage(
-                content="Initial brief",
-                from_id=assistant_id,
-                message_id="brief-1",
-            ),
-            AssistantText(content="Leader summary"),
-            ReceivedMessage(
-                from_id="human",
-                parts=[
-                    TextPart(text="Retry this leader request"),
-                    ImagePart(
-                        asset_id=asset_id,
-                        mime_type="image/png",
-                        width=1,
-                        height=1,
-                    ),
-                ],
-                message_id="msg-2",
-            ),
-            AssistantText(content="Discard this leader reply"),
-        ]
-    )
-
-    monkeypatch.setattr(leader, "supports_input_image", lambda: True)
-    monkeypatch.setattr(
-        leader,
-        "enqueue_message",
-        lambda message: queued_messages.append(message),
-    )
-
-    response = client.post(f"/api/nodes/{tab['leader_id']}/messages/msg-2/retry")
-
-    assert response.status_code == 200
-    payload = response.json()
-    assert payload["status"] == "retried"
-    assert payload["message_id"] != "msg-2"
-
-    detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
-
-    assert any(
-        entry["type"] == "ReceivedMessage"
-        and entry.get("message_id") == "brief-1"
-        and entry.get("from_id") == assistant_id
-        for entry in detail["history"]
-    )
-    assert not any(
-        entry["type"] == "ReceivedMessage" and entry.get("message_id") == "msg-2"
-        for entry in detail["history"]
-    )
-    assert not any(
-        entry["type"] == "AssistantText"
-        and entry.get("content") == "Discard this leader reply"
-        for entry in detail["history"]
-    )
-    assert any(
-        entry["type"] == "ReceivedMessage"
-        and entry.get("message_id") == payload["message_id"]
-        and entry.get("content") == "Retry this leader request[image]"
-        for entry in detail["history"]
-    )
-    assert len(queued_messages) == 1
-    assert queued_messages[0].message_id == payload["message_id"]
-    assert queued_messages[0].parts[0].text == "Retry this leader request"
-    assert queued_messages[0].parts[1].asset_id == asset_id
-
-
-def test_leader_retry_rejects_non_human_anchor(client: TestClient):
-    assistant_id = _get_assistant_id(client)
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    leader = registry.get(tab["leader_id"])
-    assert leader is not None
-    leader.history.append(
-        ReceivedMessage(
-            content="Initial brief",
-            from_id=assistant_id,
-            message_id="brief-1",
-        )
-    )
-
-    response = client.post(f"/api/nodes/{tab['leader_id']}/messages/brief-1/retry")
-
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Leader human message `brief-1` was not found."
-
-
-def test_regular_worker_retry_is_not_available_via_nodes_api(client: TestClient):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    worker = client.post(
-        f"/api/workflows/{tab['id']}/nodes",
-        json={"role_name": "Worker", "name": "Worker"},
-    ).json()
-
-    response = client.post(f"/api/nodes/{worker['id']}/messages/msg-1/retry")
-
-    assert response.status_code == 400
-    assert response.json() == {
-        "detail": "Only a Workflow Leader can retry chat history"
-    }
-
-
-def test_human_input_cannot_target_regular_worker(client: TestClient):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    worker = client.post(
-        f"/api/workflows/{tab['id']}/nodes",
-        json={"role_name": "Worker", "name": "Worker"},
-    ).json()
-
-    response = client.post(
-        f"/api/nodes/{worker['id']}/messages",
-        json={"content": "Do the work"},
-    )
-
-    assert response.status_code == 400
-    assert response.json()["detail"] == (
-        "Human input can only target Assistant or a Workflow Leader"
-    )
-
-
-def test_browser_cannot_spoof_non_human_sender_for_node_messages(client: TestClient):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    worker = client.post(
-        f"/api/workflows/{tab['id']}/nodes",
-        json={"role_name": "Worker", "name": "Worker"},
-    ).json()
-
-    response = client.post(
-        f"/api/nodes/{worker['id']}/messages",
-        json={"content": "Do the work", "from_id": "assistant"},
-    )
-
-    assert response.status_code == 400
-    assert response.json()["detail"] == (
-        "Web UI node messages must originate from `human`"
-    )
-
-
-def test_leader_message_supports_structured_parts_and_image_validation(
-    monkeypatch, client: TestClient
-):
-    tab = client.post(
-        "/api/workflows",
-        json={"title": "Execution"},
-    ).json()
-    leader = registry.get(tab["leader_id"])
-    assert leader is not None
-
-    upload_response = client.post(
-        "/api/image-assets",
-        files={"file": ("pixel.png", _ONE_PIXEL_PNG, "image/png")},
-    )
-    assert upload_response.status_code == 200
-    asset_id = upload_response.json()["id"]
-
-    monkeypatch.setattr(leader, "supports_input_image", lambda: True)
-
-    response = client.post(
-        f"/api/nodes/{tab['leader_id']}/messages",
-        json={
-            "parts": [
-                {"type": "text", "text": "Inspect this screenshot"},
-                {
-                    "type": "image",
-                    "asset_id": asset_id,
-                    "mime_type": "image/png",
-                    "width": 1,
-                    "height": 1,
-                    "alt": "Pixel",
-                },
-            ]
-        },
-    )
-
-    assert response.status_code == 200
-    detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
-    entry = next(
-        history_entry
-        for history_entry in detail["history"]
-        if history_entry["type"] == "ReceivedMessage"
-        and history_entry["message_id"] == response.json()["message_id"]
-    )
-    assert entry["parts"][0]["text"] == "Inspect this screenshot"
-    assert entry["parts"][1]["asset_id"] == asset_id