flowent 0.0.6 → 0.0.10

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

@@ -1,228 +0,0 @@
-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

@@ -1,436 +0,0 @@
-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"],
-    }