flowent 0.0.4 → 0.0.5

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

@@ -4,7 +4,7 @@ import pytest
 
 from flowent.agent import Agent
 from flowent.graph_service import create_tab
-from flowent.models import AgentState, GraphNodeRecord, NodeConfig, NodeType
+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
@@ -309,14 +309,12 @@ def test_create_agent_rejects_reserved_conductor_role(monkeypatch):
     }
 
 
-def test_create_agent_respects_write_dir_and_network_boundaries(monkeypatch, tmp_path):
+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.")]),
     )
 
-    allowed_dir = tmp_path / "allowed"
-    allowed_dir.mkdir()
     disallowed_dir = tmp_path / "disallowed"
     disallowed_dir.mkdir()
     tab = create_tab(title="Task")
@@ -327,8 +325,6 @@ def test_create_agent_respects_write_dir_and_network_boundaries(monkeypatch, tmp
             role_name="Conductor",
             tab_id=tab.id,
             tools=["create_agent"],
-            write_dirs=[str(allowed_dir)],
-            allow_network=False,
         ),
         uuid=tab.leader_id,
     )
@@ -353,90 +349,16 @@ def test_create_agent_respects_write_dir_and_network_boundaries(monkeypatch, tmp
     )
 
     assert write_dir_result == {
-        "error": f"write_dirs boundary exceeded: {disallowed_dir}"
-    }
-    assert network_result == {
-        "error": "allow_network boundary exceeded: parent disallows network access"
-    }
-
-
-def test_create_agent_also_respects_tab_leader_boundaries(monkeypatch, tmp_path):
-    monkeypatch.setattr(
-        "flowent.settings.get_settings",
-        lambda: Settings(roles=[RoleConfig(name="Worker", system_prompt="Do work.")]),
-    )
-
-    leader_dir = tmp_path / "leader"
-    leader_dir.mkdir()
-    creator_dir = tmp_path / "creator"
-    creator_dir.mkdir()
-    creator_child = creator_dir / "child"
-    creator_child.mkdir()
-    tab = create_tab(title="Task")
-
-    leader = Agent(
-        NodeConfig(
-            node_type=NodeType.AGENT,
-            role_name="Conductor",
-            tab_id=tab.id,
-            tools=[],
-            write_dirs=[str(leader_dir)],
-            allow_network=False,
-        ),
-        uuid=tab.leader_id,
-    )
-    creator = Agent(
-        NodeConfig(
-            node_type=NodeType.AGENT,
-            role_name="Worker",
-            tab_id=tab.id,
-            tools=["create_agent"],
-            write_dirs=[str(creator_dir)],
-            allow_network=True,
-        ),
-        uuid="worker",
-    )
-    registry.register(leader)
-    registry.register(creator)
-    workspace_store.upsert_node_record(
-        GraphNodeRecord(
-            id=leader.uuid,
-            config=leader.config,
-            state=AgentState.INITIALIZING,
-        )
-    )
-    workspace_store.upsert_node_record(
-        GraphNodeRecord(
-            id=creator.uuid,
-            config=creator.config,
-            state=AgentState.INITIALIZING,
+        "error": (
+            "create_agent uses the current workflow permissions; update the "
+            "workflow permissions instead"
         )
-    )
-
-    write_dir_result = json.loads(
-        CreateAgentTool().execute(
-            creator,
-            {
-                "role_name": "Worker",
-                "write_dirs": [str(creator_child)],
-            },
-        )
-    )
-    network_result = json.loads(
-        CreateAgentTool().execute(
-            creator,
-            {
-                "role_name": "Worker",
-                "allow_network": True,
-            },
-        )
-    )
-
-    assert write_dir_result == {
-        "error": f"write_dirs boundary exceeded: {creator_child}"
     }
     assert network_result == {
-        "error": "allow_network boundary exceeded: workflow Leader disallows network access"
+        "error": (
+            "create_agent uses the current workflow permissions; update the "
+            "workflow permissions instead"
+        )
     }
 
 
@@ -489,16 +411,6 @@ def test_create_agent_tool_schema_exposes_workflow_placement_options():
                 "items": {"type": "string"},
                 "description": "Optional additional tools",
             },
-            "write_dirs": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "Optional writable directories",
-            },
-            "allow_network": {
-                "type": "boolean",
-                "description": "Whether the node can access the network",
-                "default": False,
-            },
             "placement": {
                 "type": "string",
                 "enum": ["standalone", "after", "between"],

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

@@ -7,7 +7,9 @@ from flowent.graph_service import create_agent_node, create_edge, create_tab
 from flowent.models import NodeConfig, NodeType
 from flowent.registry import registry
 from flowent.settings import RoleConfig, Settings
+from flowent.tools.create_tab import CreateTabTool
 from flowent.tools.delete_tab import DeleteTabTool
+from flowent.tools.list_tabs import ListTabsTool
 from flowent.workspace_store import workspace_store
 
 
@@ -81,3 +83,34 @@ def test_delete_tab_tool_rejects_non_assistant():
     result = json.loads(DeleteTabTool().execute(agent, {"workflow_id": "tab-1"}))
 
     assert result == {"error": "Only the Assistant may delete workflows"}
+
+
+def test_create_tab_tool_rejects_non_assistant():
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Worker",
+            tools=["create_workflow"],
+        ),
+        uuid="worker",
+    )
+
+    result = json.loads(CreateTabTool().execute(agent, {"title": "Draft"}))
+
+    assert result == {"error": "Only the Assistant may create workflows"}
+    assert workspace_store.list_tabs() == []
+
+
+def test_list_tabs_tool_rejects_non_assistant():
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Worker",
+            tools=["list_workflows"],
+        ),
+        uuid="worker",
+    )
+
+    result = json.loads(ListTabsTool().execute(agent, {}))
+
+    assert result == {"error": "Only the Assistant may list workflows"}

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

@@ -444,6 +444,7 @@ def test_manage_providers_list_models_streams_model_ids(monkeypatch):
             "context_window_tokens": None,
             "input_image": False,
             "output_image": False,
+            "structured_output": False,
         },
         {
             "model": "provider-1-b",
@@ -451,6 +452,7 @@ def test_manage_providers_list_models_streams_model_ids(monkeypatch):
             "context_window_tokens": None,
             "input_image": False,
             "output_image": False,
+            "structured_output": False,
         },
     ]
     assert "".join(chunks) == (

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

@@ -48,6 +48,7 @@ def test_manage_settings_get_returns_current_settings(monkeypatch):
             "active_model": "gpt-4o",
             "input_image": None,
             "output_image": None,
+            "structured_output": None,
             "context_window_tokens": None,
             "capabilities": None,
             "resolved_context_window_tokens": None,
@@ -103,6 +104,7 @@ def test_manage_settings_update_changes_active_provider_and_model(monkeypatch):
         "active_model": "gpt-4.1",
         "input_image": None,
         "output_image": None,
+        "structured_output": None,
         "context_window_tokens": None,
         "capabilities": None,
         "resolved_context_window_tokens": None,
@@ -448,6 +450,7 @@ def test_manage_settings_update_changes_model_metadata_overrides_and_token_limit
     assert result["model"]["capabilities"] == {
         "input_image": True,
         "output_image": False,
+        "structured_output": False,
     }
     assert result["model"]["auto_compact_token_limit"] == 48000
     assert settings.model.context_window_tokens == 64000

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

@@ -5,6 +5,7 @@ import pytest
 from flowent.agent import Agent
 from flowent.models import AgentState, GraphNodeRecord, NodeConfig, NodeType, Tab
 from flowent.registry import registry
+from flowent.settings import AssistantSettings, Settings
 from flowent.tools.set_permissions import SetPermissionsTool
 from flowent.workspace_store import workspace_store
 
@@ -67,15 +68,40 @@ def _register_live_node(record: GraphNodeRecord) -> Agent:
     return node
 
 
-def test_set_permissions_updates_leader_and_clamps_existing_workers(tmp_path):
+def _grant_assistant_permissions(
+    monkeypatch,
+    *,
+    write_dirs: list[str],
+    allow_network: bool,
+) -> None:
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(
+            assistant=AssistantSettings(
+                write_dirs=list(write_dirs),
+                allow_network=allow_network,
+            )
+        ),
+    )
+
+
+def test_set_permissions_updates_workflow_boundary_for_all_nodes(monkeypatch, tmp_path):
     root_dir = tmp_path / "root"
     keep_boundary = root_dir / "keep"
     keep_dir = keep_boundary / "child"
     drop_dir = root_dir / "drop"
     keep_dir.mkdir(parents=True)
     drop_dir.mkdir(parents=True)
+    _grant_assistant_permissions(
+        monkeypatch,
+        write_dirs=[str(root_dir)],
+        allow_network=True,
+    )
 
     tab = Tab(id="tab-1", title="Task", leader_id="leader-1")
+    tab.allow_network = True
+    tab.write_dirs = [str(root_dir)]
+    tab.permissions_initialized = True
     workspace_store.upsert_tab(tab)
     leader = _make_record(
         node_id="leader-1",
@@ -135,21 +161,33 @@ def test_set_permissions_updates_leader_and_clamps_existing_workers(tmp_path):
         "write_dirs": [str(keep_boundary)],
         "updated_node_ids": ["leader-1", "worker-keep", "worker-drop"],
     }
-    assert leader_live.config.allow_network is False
-    assert leader_live.config.write_dirs == [str(keep_boundary)]
-    assert keep_live.config.allow_network is False
+    updated_tab = workspace_store.get_tab(tab.id)
+    assert updated_tab is not None
+    assert updated_tab.allow_network is False
+    assert updated_tab.write_dirs == [str(keep_boundary)]
+    assert leader_live.config.allow_network is True
+    assert leader_live.config.write_dirs == [str(root_dir)]
+    assert keep_live.config.allow_network is True
     assert keep_live.config.write_dirs == [str(keep_dir)]
-    assert drop_live.config.allow_network is False
-    assert drop_live.config.write_dirs == []
+    assert drop_live.config.allow_network is True
+    assert drop_live.config.write_dirs == [str(drop_dir)]
 
 
-def test_set_permissions_keeps_omitted_fields_unchanged(tmp_path):
+def test_set_permissions_keeps_omitted_fields_unchanged(monkeypatch, tmp_path):
     root_dir = tmp_path / "root"
     narrowed_dir = root_dir / "narrowed"
     root_dir.mkdir()
     narrowed_dir.mkdir()
+    _grant_assistant_permissions(
+        monkeypatch,
+        write_dirs=[str(root_dir)],
+        allow_network=False,
+    )
 
     tab = Tab(id="tab-1", title="Task", leader_id="leader-1")
+    tab.allow_network = True
+    tab.write_dirs = [str(root_dir)]
+    tab.permissions_initialized = True
     workspace_store.upsert_tab(tab)
     leader = _make_record(
         node_id="leader-1",
@@ -183,17 +221,32 @@ def test_set_permissions_keeps_omitted_fields_unchanged(tmp_path):
 
     assert result["allow_network"] is True
     assert result["write_dirs"] == [str(narrowed_dir)]
+    updated_tab = workspace_store.get_tab(tab.id)
+    assert updated_tab is not None
+    assert updated_tab.allow_network is True
+    assert updated_tab.write_dirs == [str(narrowed_dir)]
     assert leader_live.config.allow_network is True
-    assert leader_live.config.write_dirs == [str(narrowed_dir)]
+    assert leader_live.config.write_dirs == [str(root_dir)]
 
 
-def test_set_permissions_does_not_auto_broaden_existing_workers(tmp_path):
+def test_set_permissions_broadens_workflow_boundary_without_mutating_workers(
+    monkeypatch,
+    tmp_path,
+):
     root_dir = tmp_path / "root"
     current_boundary = root_dir / "current"
     worker_dir = current_boundary / "child"
     worker_dir.mkdir(parents=True)
+    _grant_assistant_permissions(
+        monkeypatch,
+        write_dirs=[str(root_dir)],
+        allow_network=True,
+    )
 
     tab = Tab(id="tab-1", title="Task", leader_id="leader-1")
+    tab.allow_network = False
+    tab.write_dirs = [str(current_boundary)]
+    tab.permissions_initialized = True
     workspace_store.upsert_tab(tab)
     leader = _make_record(
         node_id="leader-1",
@@ -237,15 +290,30 @@ def test_set_permissions_does_not_auto_broaden_existing_workers(tmp_path):
 
     assert result["allow_network"] is True
     assert result["write_dirs"] == [str(root_dir)]
+    updated_tab = workspace_store.get_tab(tab.id)
+    assert updated_tab is not None
+    assert updated_tab.allow_network is True
+    assert updated_tab.write_dirs == [str(root_dir)]
     assert worker_live.config.allow_network is False
     assert worker_live.config.write_dirs == [str(worker_dir)]
 
 
-def test_set_permissions_rejects_allow_network_outside_caller_boundary(tmp_path):
+def test_set_permissions_rejects_allow_network_outside_caller_boundary(
+    monkeypatch,
+    tmp_path,
+):
     root_dir = tmp_path / "root"
     root_dir.mkdir()
+    _grant_assistant_permissions(
+        monkeypatch,
+        write_dirs=[str(root_dir)],
+        allow_network=False,
+    )
 
     tab = Tab(id="tab-1", title="Task", leader_id="leader-1")
+    tab.allow_network = False
+    tab.write_dirs = [str(root_dir)]
+    tab.permissions_initialized = True
     workspace_store.upsert_tab(tab)
     workspace_store.upsert_node_record(
         _make_record(
@@ -282,13 +350,24 @@ def test_set_permissions_rejects_allow_network_outside_caller_boundary(tmp_path)
     }
 
 
-def test_set_permissions_rejects_write_dirs_outside_caller_boundary(tmp_path):
+def test_set_permissions_rejects_write_dirs_outside_caller_boundary(
+    monkeypatch,
+    tmp_path,
+):
     caller_dir = tmp_path / "caller"
     other_dir = tmp_path / "other"
     caller_dir.mkdir()
     other_dir.mkdir()
+    _grant_assistant_permissions(
+        monkeypatch,
+        write_dirs=[str(caller_dir)],
+        allow_network=True,
+    )
 
     tab = Tab(id="tab-1", title="Task", leader_id="leader-1")
+    tab.allow_network = False
+    tab.write_dirs = [str(caller_dir)]
+    tab.permissions_initialized = True
     workspace_store.upsert_tab(tab)
     workspace_store.upsert_node_record(
         _make_record(
@@ -323,13 +402,18 @@ def test_set_permissions_rejects_write_dirs_outside_caller_boundary(tmp_path):
     assert result == {"error": f"write_dirs boundary exceeded: {other_dir}"}
 
 
-def test_set_permissions_allows_explicitly_granted_non_assistant_agent(tmp_path):
+def test_set_permissions_allows_explicitly_granted_non_assistant_agent_for_own_workflow(
+    tmp_path,
+):
     root_dir = tmp_path / "root"
     narrowed_dir = root_dir / "narrowed"
     root_dir.mkdir()
     narrowed_dir.mkdir()
 
     tab = Tab(id="tab-1", title="Task", leader_id="leader-1")
+    tab.allow_network = True
+    tab.write_dirs = [str(root_dir)]
+    tab.permissions_initialized = True
     workspace_store.upsert_tab(tab)
     workspace_store.upsert_node_record(
         _make_record(
@@ -367,6 +451,126 @@ def test_set_permissions_allows_explicitly_granted_non_assistant_agent(tmp_path)
 
     assert result["tab_id"] == tab.id
     assert result["write_dirs"] == [str(narrowed_dir)]
+    updated_tab = workspace_store.get_tab(tab.id)
+    assert updated_tab is not None
+    assert updated_tab.write_dirs == [str(narrowed_dir)]
+
+
+def test_set_permissions_rejects_non_assistant_cross_workflow(tmp_path):
+    root_dir = tmp_path / "root"
+    root_dir.mkdir()
+
+    own_tab = Tab(id="tab-1", title="Own", leader_id="leader-1")
+    own_tab.allow_network = True
+    own_tab.write_dirs = [str(root_dir)]
+    own_tab.permissions_initialized = True
+    other_tab = Tab(id="tab-2", title="Other", leader_id="leader-2")
+    other_tab.allow_network = True
+    other_tab.write_dirs = [str(root_dir)]
+    other_tab.permissions_initialized = True
+    workspace_store.upsert_tab(own_tab)
+    workspace_store.upsert_tab(other_tab)
+    workspace_store.upsert_node_record(
+        _make_record(
+            node_id="leader-1",
+            tab_id=own_tab.id,
+            role_name="Conductor",
+            name="Leader",
+            write_dirs=[str(root_dir)],
+            allow_network=True,
+            tools=["set_permissions"],
+        )
+    )
+    workspace_store.upsert_node_record(
+        _make_record(
+            node_id="leader-2",
+            tab_id=other_tab.id,
+            role_name="Conductor",
+            name="Leader",
+            write_dirs=[str(root_dir)],
+            allow_network=True,
+        )
+    )
+    leader = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=own_tab.id,
+            name="Leader",
+            tools=["set_permissions"],
+            write_dirs=[str(root_dir)],
+            allow_network=True,
+        ),
+        uuid="leader-1",
+    )
+
+    result = json.loads(
+        SetPermissionsTool().execute(
+            leader,
+            {
+                "workflow_id": other_tab.id,
+                "write_dirs": [],
+            },
+        )
+    )
+
+    assert result == {
+        "error": "Workflow permissions can only be changed for this workflow"
+    }
+    updated_other_tab = workspace_store.get_tab(other_tab.id)
+    assert updated_other_tab is not None
+    assert updated_other_tab.write_dirs == [str(root_dir)]
+
+
+def test_set_permissions_migrates_legacy_leader_permissions(tmp_path):
+    root_dir = tmp_path / "root"
+    narrowed_dir = root_dir / "narrowed"
+    root_dir.mkdir()
+    narrowed_dir.mkdir()
+
+    tab = Tab(id="tab-1", title="Task", leader_id="leader-1")
+    workspace_store.upsert_tab(tab)
+    workspace_store.upsert_node_record(
+        _make_record(
+            node_id="leader-1",
+            tab_id=tab.id,
+            role_name="Conductor",
+            name="Leader",
+            write_dirs=[str(root_dir)],
+            allow_network=True,
+            tools=["set_permissions"],
+        )
+    )
+    leader = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tab_id=tab.id,
+            name="Leader",
+            tools=["set_permissions"],
+            write_dirs=[str(root_dir)],
+            allow_network=True,
+        ),
+        uuid="leader-1",
+    )
+
+    result = json.loads(
+        SetPermissionsTool().execute(
+            leader,
+            {
+                "workflow_id": tab.id,
+                "write_dirs": [str(narrowed_dir)],
+            },
+        )
+    )
+
+    updated_tab = workspace_store.get_tab(tab.id)
+    assert result["allow_network"] is True
+    assert result["write_dirs"] == [str(narrowed_dir)]
+    assert updated_tab is not None
+    assert updated_tab.permissions_initialized is True
+    assert updated_tab.allow_network is True
+    assert updated_tab.write_dirs == [str(narrowed_dir)]
 
 
 def test_set_permissions_tool_schema_matches_patch_contract():

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

@@ -3,6 +3,17 @@ from flowent.models import NodeConfig, NodeType
 from flowent.tools import build_tool_registry
 
 
+class _FakeMCPService:
+    def __init__(self, descriptors):
+        self._descriptors = descriptors
+
+    def list_agent_dynamic_tools(self, agent):
+        return list(self._descriptors)
+
+    def list_discovered_tools(self):
+        return list(self._descriptors)
+
+
 def test_empty_tools_list_grants_minimum_tools():
     agent = Agent(NodeConfig(node_type=NodeType.AGENT, tools=[]))
 
@@ -78,6 +89,98 @@ def test_tool_registry_grants_workflow_graph_tools_when_explicitly_allowed():
     ]
 
 
+def test_tool_registry_filters_assistant_only_tools_for_workflow_nodes():
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Conductor",
+            tools=[
+                "create_workflow",
+                "delete_workflow",
+                "set_permissions",
+                "create_agent",
+                "connect",
+                "list_workflows",
+                "manage_settings",
+            ],
+        )
+    )
+
+    tools = build_tool_registry().get_tools_for_agent(agent)
+
+    assert [tool.name for tool in tools] == [
+        "idle",
+        "sleep",
+        "todo",
+        "contacts",
+        "send",
+        "set_permissions",
+        "create_agent",
+        "connect",
+    ]
+
+
+def test_tool_registry_filters_assistant_only_mcp_tools_for_workflow_nodes(
+    monkeypatch,
+):
+    from flowent.mcp_service import MCPToolDescriptor
+
+    workflow_tool = MCPToolDescriptor(
+        server_name="flowent",
+        tool_name="list_workflows",
+        fully_qualified_id="mcp__flowent__list_workflows",
+    )
+    regular_tool = MCPToolDescriptor(
+        server_name="flowent",
+        tool_name="search_notes",
+        fully_qualified_id="mcp__flowent__search_notes",
+    )
+    fake_service = _FakeMCPService([workflow_tool, regular_tool])
+    monkeypatch.setattr("flowent.mcp_service.mcp_service", fake_service)
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Worker",
+            tools=[
+                "mcp__flowent__list_workflows",
+                "mcp__flowent__search_notes",
+            ],
+        )
+    )
+
+    tools = build_tool_registry().get_tools_for_agent(agent)
+
+    assert "mcp__flowent__list_workflows" not in {tool.name for tool in tools}
+    assert "mcp__flowent__search_notes" in {tool.name for tool in tools}
+
+
+def test_build_tools_for_role_filters_assistant_only_mcp_tools(monkeypatch):
+    from flowent.graph_service import build_tools_for_role
+    from flowent.settings import RoleConfig, Settings
+
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(
+            roles=[
+                RoleConfig(
+                    name="Worker",
+                    system_prompt="Do work.",
+                    included_tools=["mcp__flowent__list_workflows", "read"],
+                )
+            ]
+        ),
+    )
+
+    tools = build_tools_for_role(
+        "Worker",
+        requested_tools=["mcp__flowent__delete_workflow", "mcp__flowent__search_notes"],
+    )
+
+    assert "mcp__flowent__list_workflows" not in tools
+    assert "mcp__flowent__delete_workflow" not in tools
+    assert "mcp__flowent__search_notes" in tools
+
+
 def test_tool_registry_shows_management_tools_in_agent_visible_list():
     visible_tool_names = {
         tool.name for tool in build_tool_registry().list_tools(agent_visible_only=True)

package/backend/uv.lock

@@ -286,7 +286,7 @@ wheels = [
 
 [[package]]
 name = "flowent"
-version = "0.0.4"
+version = "0.0.5"
 source = { editable = "." }
 dependencies = [
     { name = "curl-cffi" },