flowent 0.0.1 → 0.0.4

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

@@ -0,0 +1,116 @@
+from fastapi.testclient import TestClient
+
+
+def test_mcp_api_returns_only_external_server_state(client: TestClient, monkeypatch):
+    monkeypatch.setattr(
+        "flowent.routes.mcp.mcp_service.list_server_payloads",
+        lambda: [
+            {
+                "config": {
+                    "name": "filesystem",
+                    "transport": "stdio",
+                    "enabled": True,
+                    "required": False,
+                    "startup_timeout_sec": 10,
+                    "tool_timeout_sec": 30,
+                    "enabled_tools": [],
+                    "disabled_tools": [],
+                    "scopes": [],
+                    "oauth_resource": "",
+                    "launcher": "",
+                    "command": "npx",
+                    "args": ["-y", "demo-mcp"],
+                    "env": {},
+                    "env_vars": [],
+                    "cwd": "",
+                    "url": "",
+                    "bearer_token_env_var": "",
+                    "http_headers": {},
+                    "env_http_headers": [],
+                },
+                "snapshot": {
+                    "server_name": "filesystem",
+                    "transport": "stdio",
+                    "status": "connected",
+                    "auth_status": "unsupported",
+                    "last_auth_result": None,
+                    "last_refresh_at": 1710000000,
+                    "last_refresh_result": "success",
+                    "last_error": None,
+                    "tools": [],
+                    "resources": [],
+                    "resource_templates": [],
+                    "prompts": [],
+                    "capability_counts": {
+                        "tools": 0,
+                        "resources": 0,
+                        "resource_templates": 0,
+                        "prompts": 0,
+                    },
+                },
+                "visibility": {
+                    "scope": "global",
+                    "active": True,
+                },
+                "activity": [],
+            }
+        ],
+    )
+
+    response = client.get("/api/mcp")
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "servers": [
+            {
+                "config": {
+                    "name": "filesystem",
+                    "transport": "stdio",
+                    "enabled": True,
+                    "required": False,
+                    "startup_timeout_sec": 10,
+                    "tool_timeout_sec": 30,
+                    "enabled_tools": [],
+                    "disabled_tools": [],
+                    "scopes": [],
+                    "oauth_resource": "",
+                    "launcher": "",
+                    "command": "npx",
+                    "args": ["-y", "demo-mcp"],
+                    "env": {},
+                    "env_vars": [],
+                    "cwd": "",
+                    "url": "",
+                    "bearer_token_env_var": "",
+                    "http_headers": {},
+                    "env_http_headers": [],
+                },
+                "snapshot": {
+                    "server_name": "filesystem",
+                    "transport": "stdio",
+                    "status": "connected",
+                    "auth_status": "unsupported",
+                    "last_auth_result": None,
+                    "last_refresh_at": 1710000000,
+                    "last_refresh_result": "success",
+                    "last_error": None,
+                    "tools": [],
+                    "resources": [],
+                    "resource_templates": [],
+                    "prompts": [],
+                    "capability_counts": {
+                        "tools": 0,
+                        "resources": 0,
+                        "resource_templates": 0,
+                        "prompts": 0,
+                    },
+                },
+                "visibility": {
+                    "scope": "global",
+                    "active": True,
+                },
+                "activity": [],
+            }
+        ],
+    }
+    assert "flowent_server" not in response.json()

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

@@ -0,0 +1,33 @@
+from fastapi.testclient import TestClient
+
+
+def test_tools_api_shows_agent_visible_management_tools(client: TestClient):
+    response = client.get("/api/tools")
+
+    assert response.status_code == 200
+    tool_names = {tool["name"] for tool in response.json()["tools"]}
+    assert "create_root" not in tool_names
+    assert "manage_providers" in tool_names
+    assert "manage_roles" in tool_names
+    assert "manage_settings" in tool_names
+    assert "manage_prompts" in tool_names
+    assert "set_permissions" in tool_names
+    assert "sleep" in tool_names
+    assert "delete_workflow" in tool_names
+    assert "create_agent" in tool_names
+    assert "connect" in tool_names
+
+
+def test_settings_bootstrap_returns_settings_related_resources(client: TestClient):
+    response = client.get("/api/settings/bootstrap")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["version"]
+    assert "settings" in payload
+    assert "providers" in payload
+    assert "roles" in payload
+    role_names = {role["name"] for role in payload["roles"]}
+    assert "Steward" in role_names
+    assert "Worker" in role_names
+    assert "Designer" in role_names

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

@@ -0,0 +1,486 @@
+import os
+import time
+from uuid import UUID
+
+from fastapi.testclient import TestClient
+
+from flowent.models import (
+    AgentState,
+    AssistantText,
+    ImagePart,
+    ReceivedMessage,
+    TextPart,
+)
+from flowent.registry import registry
+from flowent.routes.nodes import router as nodes_router
+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)
+
+
+def test_worker_and_leader_are_stable_contacts_without_explicit_edge(
+    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()
+
+    detail_without_edge = client.get(f"/api/nodes/{worker['id']}")
+
+    assert detail_without_edge.status_code == 200
+    assert detail_without_edge.json()["contacts"] == [tab["leader_id"]]
+    leader_without_edge = client.get(f"/api/nodes/{tab['leader_id']}")
+    assert leader_without_edge.status_code == 200
+    assert worker["id"] in leader_without_edge.json()["contacts"]
+
+    edge_response = client.post(
+        f"/api/workflows/{tab['id']}/edges",
+        json={
+            "from_node_id": tab["leader_id"],
+            "to_node_id": worker["id"],
+        },
+    )
+
+    assert edge_response.status_code == 400
+    assert edge_response.json()["detail"] == (
+        "Workflow Leader does not participate in Workflow Graph edges"
+    )
+
+
+def test_direct_node_message_api_is_not_available(client: TestClient):
+    assert not any(
+        getattr(route, "path", None) == "/api/nodes/{node_id}/message"
+        for route in nodes_router.routes
+    )
+
+
+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
+
+
+def test_get_node_detail_includes_state_entries_in_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
+    history = response.json()["history"]
+    assert any(
+        entry["type"] == "StateEntry" and entry["state"] == "running"
+        for entry in 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_human_input_can_be_sent_directly_to_workflow_leader(client: TestClient):
+    tab = client.post(
+        "/api/workflows",
+        json={"title": "Execution"},
+    ).json()
+
+    response = client.post(
+        f"/api/nodes/{tab['leader_id']}/messages",
+        json={"content": "/help 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"] == "/help 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"] == "/help investigate the failure"
+        for entry in 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

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

@@ -0,0 +1,47 @@
+from fastapi.testclient import TestClient
+
+from flowent.settings import Settings
+
+
+def test_prompts_api_reads_and_updates_custom_prompt(
+    client: TestClient,
+    monkeypatch,
+):
+    settings = Settings(
+        custom_prompt="Initial global prompt.",
+        custom_post_prompt="Initial runtime prompt.",
+    )
+    saved: list[tuple[str, str]] = []
+
+    monkeypatch.setattr("flowent.routes.prompts.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.routes.prompts.save_settings",
+        lambda current: saved.append(
+            (current.custom_prompt, current.custom_post_prompt)
+        ),
+    )
+
+    get_response = client.get("/api/prompts")
+
+    assert get_response.status_code == 200
+    assert get_response.json() == {
+        "custom_prompt": "Initial global prompt.",
+        "custom_post_prompt": "Initial runtime prompt.",
+    }
+
+    put_response = client.put(
+        "/api/prompts",
+        json={
+            "custom_prompt": "Updated global prompt.",
+            "custom_post_prompt": "Updated runtime prompt.",
+        },
+    )
+
+    assert put_response.status_code == 200
+    assert put_response.json() == {
+        "custom_prompt": "Updated global prompt.",
+        "custom_post_prompt": "Updated runtime prompt.",
+    }
+    assert settings.custom_prompt == "Updated global prompt."
+    assert settings.custom_post_prompt == "Updated runtime prompt."
+    assert saved == [("Updated global prompt.", "Updated runtime prompt.")]