flowent 0.0.1 → 0.0.5

package/backend/tests/unit/tools/test_connect_tool.py

@@ -0,0 +1,228 @@
+import json
+
+import pytest
+
+from flowent.agent import Agent
+from flowent.graph_service import build_workflow_node_definition, create_tab
+from flowent.models import (
+    AgentState,
+    GraphNodeRecord,
+    NodeConfig,
+    NodeType,
+    WorkflowNodeKind,
+)
+from flowent.registry import registry
+from flowent.tools.connect import ConnectTool
+from flowent.workspace_store import workspace_store
+
+
+@pytest.fixture(autouse=True)
+def reset_runtime_state(monkeypatch, tmp_path):
+    import flowent.settings as settings_module
+
+    settings_file = tmp_path / "settings.json"
+    settings_file.write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+    registry.reset()
+    workspace_store.reset_cache()
+    yield
+    registry.reset()
+    workspace_store.reset_cache()
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+
+
+def register_tab_agent(
+    *,
+    node_id: str,
+    tab_id: str,
+    name: str,
+    role_name: str = "Worker",
+    tools: list[str] | None = None,
+) -> Agent:
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name=role_name,
+            tab_id=tab_id,
+            name=name,
+            tools=list(tools or []),
+        ),
+        uuid=node_id,
+    )
+    registry.register(agent)
+    workspace_store.upsert_node_record(
+        GraphNodeRecord(
+            id=node_id,
+            config=agent.config,
+            state=AgentState.INITIALIZING,
+        )
+    )
+    tab = workspace_store.get_tab(tab_id)
+    assert tab is not None
+    tab.definition.nodes.append(
+        build_workflow_node_definition(
+            node_id=node_id,
+            node_kind=WorkflowNodeKind.AGENT,
+            config={"role_name": role_name, "name": name},
+        )
+    )
+    workspace_store.upsert_tab(tab)
+    return agent
+
+
+def register_graph_node(
+    *,
+    node_id: str,
+    tab_id: str,
+    node_type: WorkflowNodeKind,
+    name: str,
+) -> None:
+    tab = workspace_store.get_tab(tab_id)
+    assert tab is not None
+    tab.definition.nodes.append(
+        build_workflow_node_definition(
+            node_id=node_id,
+            node_kind=node_type,
+            config={"name": name},
+        )
+    )
+    workspace_store.upsert_tab(tab)
+
+
+def test_connect_tool_creates_directed_workflow_edge():
+    tab = create_tab(title="Task")
+    leader = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            name="Leader",
+            tools=["connect"],
+        ),
+        uuid=tab.leader_id,
+    )
+    registry.register(leader)
+    left = register_tab_agent(
+        node_id="worker-a",
+        tab_id=tab.id,
+        name="Worker A",
+    )
+    right = register_tab_agent(
+        node_id="worker-b",
+        tab_id=tab.id,
+        name="Worker B",
+    )
+
+    result = json.loads(
+        ConnectTool().execute(
+            leader,
+            {
+                "from": left.uuid,
+                "to": right.uuid,
+                "from_port_key": "out",
+                "to_port_key": "in",
+            },
+        )
+    )
+
+    assert result["tab_id"] == tab.id
+    assert result["from_node_id"] == "worker-a"
+    assert result["from_port_key"] == "out"
+    assert result["to_node_id"] == "worker-b"
+    assert result["to_port_key"] == "in"
+    assert "kind" not in result
+    assert left.get_connections_snapshot() == []
+    assert right.get_connections_snapshot() == []
+    stored_edges = workspace_store.list_edges(tab.id)
+    assert len(stored_edges) == 1
+    assert stored_edges[0].from_node_id == "worker-a"
+    assert stored_edges[0].to_node_id == "worker-b"
+    assert stored_edges[0].from_port_key == "out"
+    assert stored_edges[0].to_port_key == "in"
+
+    duplicate_result = json.loads(
+        ConnectTool().execute(
+            leader,
+            {
+                "from": left.uuid,
+                "to": right.uuid,
+            },
+        )
+    )
+    assert duplicate_result == {"error": "Duplicate edges are not allowed"}
+
+
+def test_connect_tool_resolves_non_agent_workflow_nodes_by_name():
+    tab = create_tab(title="Task")
+    leader = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            name="Leader",
+            tools=["connect"],
+        ),
+        uuid=tab.leader_id,
+    )
+    registry.register(leader)
+    register_tab_agent(
+        node_id="worker-a",
+        tab_id=tab.id,
+        name="Worker A",
+    )
+    register_graph_node(
+        node_id="code-a",
+        tab_id=tab.id,
+        node_type=WorkflowNodeKind.CODE,
+        name="Formatter",
+    )
+
+    result = json.loads(
+        ConnectTool().execute(
+            leader,
+            {
+                "from": "Worker A",
+                "to": "Formatter",
+            },
+        )
+    )
+
+    assert result["from_node_id"] == "worker-a"
+    assert result["to_node_id"] == "code-a"
+    assert "kind" not in result
+
+
+def test_connect_tool_rejects_leader_endpoints():
+    tab = create_tab(title="Task")
+    leader = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            name="Leader",
+            tools=["connect"],
+        ),
+        uuid=tab.leader_id,
+    )
+    registry.register(leader)
+    register_tab_agent(
+        node_id="worker-a",
+        tab_id=tab.id,
+        name="Worker A",
+    )
+
+    result = json.loads(
+        ConnectTool().execute(
+            leader,
+            {
+                "from": leader.uuid,
+                "to": "worker-a",
+            },
+        )
+    )
+
+    assert result == {
+        "error": "Workflow Leader does not participate in Workflow Graph edges"
+    }
+    assert workspace_store.list_edges(tab.id) == []

package/backend/tests/unit/tools/test_create_agent_tool.py

@@ -0,0 +1,436 @@
+import json
+
+import pytest
+
+from flowent.agent import Agent
+from flowent.graph_service import create_tab
+from flowent.models import NodeConfig, NodeType
+from flowent.registry import registry
+from flowent.settings import CONDUCTOR_ROLE_NAME, RoleConfig, Settings
+from flowent.tools.create_agent import CreateAgentTool
+from flowent.workspace_store import workspace_store
+
+
+@pytest.fixture(autouse=True)
+def reset_runtime_state(monkeypatch, tmp_path):
+    import flowent.settings as settings_module
+
+    settings_file = tmp_path / "settings.json"
+    settings_file.write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+    registry.reset()
+    workspace_store.reset_cache()
+    yield
+    registry.reset()
+    workspace_store.reset_cache()
+    monkeypatch.setattr(settings_module, "_cached_settings", None)
+
+
+def test_leader_create_agent_defaults_to_current_tab_without_network_edge(
+    monkeypatch,
+):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(
+            roles=[
+                RoleConfig(
+                    name="Worker",
+                    system_prompt="Do work.",
+                    included_tools=["read"],
+                )
+            ]
+        ),
+    )
+    tab = create_tab(title="Task")
+
+    owner = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            tools=["create_agent"],
+            write_dirs=["/tmp/workspace"],
+            allow_network=False,
+        ),
+        uuid=tab.leader_id,
+    )
+    registry.register(owner)
+
+    result = json.loads(
+        CreateAgentTool().execute(
+            owner,
+            {
+                "role_name": "Worker",
+                "name": "Peer Worker",
+            },
+        )
+    )
+
+    assert result["config"]["tab_id"] == tab.id
+    assert result["config"]["name"] == "Peer Worker"
+    assert owner.get_connections_snapshot() == []
+    assert workspace_store.list_edges(tab.id) == []
+
+
+def test_create_agent_places_new_agent_after_anchor(monkeypatch):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(
+            roles=[
+                RoleConfig(
+                    name="Worker",
+                    system_prompt="Do work.",
+                    included_tools=["read"],
+                )
+            ]
+        ),
+    )
+    tab = create_tab(title="Task")
+
+    owner = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            tools=["create_agent"],
+            write_dirs=["/tmp/workspace"],
+            allow_network=False,
+        ),
+        uuid=tab.leader_id,
+    )
+    registry.register(owner)
+
+    anchor = json.loads(
+        CreateAgentTool().execute(
+            owner,
+            {
+                "role_name": "Worker",
+                "name": "Anchor Worker",
+            },
+        )
+    )
+    result = json.loads(
+        CreateAgentTool().execute(
+            owner,
+            {
+                "role_name": "Worker",
+                "name": "Placed Worker",
+                "placement": "after",
+                "after_node_id": anchor["id"],
+            },
+        )
+    )
+
+    assert result["config"]["tab_id"] == tab.id
+    assert owner.get_connections_snapshot() == []
+    assert [
+        (edge.from_node_id, edge.to_node_id)
+        for edge in workspace_store.list_edges(tab.id)
+    ] == [(anchor["id"], result["id"])]
+
+
+def test_create_agent_rejects_assistant_for_ordinary_nodes(monkeypatch):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(
+            roles=[RoleConfig(name="Worker", system_prompt="Do work.")],
+        ),
+    )
+    create_tab(title="Task")
+
+    assistant = Agent(
+        NodeConfig(
+            node_type=NodeType.ASSISTANT,
+            role_name="Steward",
+            tools=["create_agent"],
+        ),
+        uuid="assistant",
+    )
+
+    result = json.loads(
+        CreateAgentTool().execute(
+            assistant,
+            {
+                "role_name": "Worker",
+            },
+        )
+    )
+
+    assert result == {"error": "Assistant may not create ordinary task nodes directly"}
+
+
+def test_create_agent_allows_explicitly_granted_task_node(monkeypatch):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(
+            roles=[
+                RoleConfig(
+                    name="Worker",
+                    system_prompt="Do work.",
+                    included_tools=["create_agent"],
+                )
+            ],
+        ),
+    )
+    tab = create_tab(title="Task")
+
+    leader = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            tools=["create_agent"],
+            write_dirs=["/tmp/workspace"],
+            allow_network=True,
+        ),
+        uuid=tab.leader_id,
+    )
+    registry.register(leader)
+    creator = json.loads(
+        CreateAgentTool().execute(
+            leader,
+            {
+                "role_name": "Worker",
+                "name": "Creator Worker",
+            },
+        )
+    )
+    creator_node = registry.get(creator["id"])
+    assert creator_node is not None
+
+    result = json.loads(
+        CreateAgentTool().execute(
+            creator_node,
+            {
+                "role_name": "Worker",
+                "name": "Nested Worker",
+            },
+        )
+    )
+
+    assert result["config"]["tab_id"] == tab.id
+    assert result["config"]["name"] == "Nested Worker"
+    assert creator_node.get_connections_snapshot() == []
+    assert workspace_store.list_edges(tab.id) == []
+
+
+def test_create_agent_rejects_task_node_without_tool(monkeypatch):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(roles=[RoleConfig(name="Worker", system_prompt="Do work.")]),
+    )
+    tab = create_tab(title="Task")
+
+    worker = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Worker",
+            tab_id=tab.id,
+            tools=[],
+        ),
+        uuid="worker",
+    )
+
+    result = json.loads(
+        CreateAgentTool().execute(
+            worker,
+            {
+                "role_name": "Worker",
+            },
+        )
+    )
+
+    assert result == {"error": "create_agent is not enabled for this node"}
+
+
+def test_create_agent_rejects_workflow_id_parameter(monkeypatch):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(roles=[RoleConfig(name="Worker", system_prompt="Do work.")]),
+    )
+    tab = create_tab(title="Task")
+
+    owner = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            tools=["create_agent"],
+        ),
+        uuid=tab.leader_id,
+    )
+
+    result = json.loads(
+        CreateAgentTool().execute(
+            owner,
+            {
+                "tab_id": tab.id,
+                "role_name": "Worker",
+            },
+        )
+    )
+
+    assert result == {"error": "create_agent does not accept workflow_id"}
+
+
+def test_create_agent_rejects_reserved_conductor_role(monkeypatch):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(
+            roles=[RoleConfig(name=CONDUCTOR_ROLE_NAME, system_prompt="Orchestrate.")],
+        ),
+    )
+    tab = create_tab(title="Task")
+
+    leader = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            tools=["create_agent"],
+        ),
+        uuid=tab.leader_id,
+    )
+    registry.register(leader)
+
+    result = json.loads(
+        CreateAgentTool().execute(
+            leader,
+            {
+                "role_name": f" {CONDUCTOR_ROLE_NAME} ",
+                "name": "Task Conductor",
+            },
+        )
+    )
+
+    assert result == {
+        "error": f"Role '{CONDUCTOR_ROLE_NAME}' is reserved for a workflow Leader"
+    }
+
+
+def test_create_agent_rejects_node_level_permissions(monkeypatch, tmp_path):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(roles=[RoleConfig(name="Worker", system_prompt="Do work.")]),
+    )
+
+    disallowed_dir = tmp_path / "disallowed"
+    disallowed_dir.mkdir()
+    tab = create_tab(title="Task")
+
+    owner = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            tools=["create_agent"],
+        ),
+        uuid=tab.leader_id,
+    )
+
+    write_dir_result = json.loads(
+        CreateAgentTool().execute(
+            owner,
+            {
+                "role_name": "Worker",
+                "write_dirs": [str(disallowed_dir)],
+            },
+        )
+    )
+    network_result = json.loads(
+        CreateAgentTool().execute(
+            owner,
+            {
+                "role_name": "Worker",
+                "allow_network": True,
+            },
+        )
+    )
+
+    assert write_dir_result == {
+        "error": (
+            "create_agent uses the current workflow permissions; update the "
+            "workflow permissions instead"
+        )
+    }
+    assert network_result == {
+        "error": (
+            "create_agent uses the current workflow permissions; update the "
+            "workflow permissions instead"
+        )
+    }
+
+
+def test_create_agent_rejects_removed_connect_to_creator_parameter(monkeypatch):
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(roles=[RoleConfig(name="Worker", system_prompt="Do work.")]),
+    )
+    tab = create_tab(title="Task")
+
+    owner = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            tools=["create_agent"],
+        ),
+        uuid=tab.leader_id,
+    )
+
+    result = json.loads(
+        CreateAgentTool().execute(
+            owner,
+            {
+                "role_name": "Worker",
+                "connect_to_creator": "yes",
+            },
+        )
+    )
+
+    assert result == {
+        "error": "create_agent no longer supports connect_to_creator; use placement"
+    }
+
+
+def test_create_agent_tool_schema_exposes_workflow_placement_options():
+    assert CreateAgentTool.parameters == {
+        "type": "object",
+        "properties": {
+            "role_name": {
+                "type": "string",
+                "description": "Role assigned to the new agent",
+            },
+            "name": {
+                "type": "string",
+                "description": "Optional human-readable node name",
+            },
+            "tools": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Optional additional tools",
+            },
+            "placement": {
+                "type": "string",
+                "enum": ["standalone", "after", "between"],
+                "description": (
+                    "How to place the new agent inside the current workflow graph"
+                ),
+                "default": "standalone",
+            },
+            "after_node_id": {
+                "type": "string",
+                "description": "Anchor node id when placement is `after`",
+            },
+            "between_from_node_id": {
+                "type": "string",
+                "description": "Upstream node id when placement is `between`",
+            },
+            "between_to_node_id": {
+                "type": "string",
+                "description": "Downstream node id when placement is `between`",
+            },
+        },
+        "required": ["role_name"],
+    }