flowent 0.0.6 → 0.0.10

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

@@ -1,116 +0,0 @@
-import json
-
-import pytest
-
-from flowent.agent import Agent
-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
-
-
-@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_delete_tab_tool_deletes_tab_and_graph(monkeypatch):
-    monkeypatch.setattr(
-        "flowent.settings.get_settings",
-        lambda: Settings(
-            roles=[
-                RoleConfig(
-                    name="Worker",
-                    system_prompt="Do work.",
-                    included_tools=["read"],
-                )
-            ]
-        ),
-    )
-
-    assistant = Agent(
-        NodeConfig(node_type=NodeType.ASSISTANT, tools=["delete_workflow"]),
-        uuid="assistant",
-    )
-    registry.register(assistant)
-
-    tab = create_tab(title="Cleanup")
-    left, error = create_agent_node(role_name="Worker", tab_id=tab.id, name="Left")
-    assert error is None and left is not None
-    right, error = create_agent_node(role_name="Worker", tab_id=tab.id, name="Right")
-    assert error is None and right is not None
-    edge, error = create_edge(from_node_id=left.id, to_node_id=right.id)
-    assert error is None and edge is not None
-
-    result = json.loads(DeleteTabTool().execute(assistant, {"workflow_id": tab.id}))
-
-    assert result["id"] == tab.id
-    assert set(result["removed_node_ids"]) == {tab.leader_id, left.id, right.id}
-    assert result["removed_edge_ids"] == [edge.id]
-    assert workspace_store.get_tab(tab.id) is None
-    assert workspace_store.list_node_records(tab.id) == []
-    assert workspace_store.list_edges(tab.id) == []
-    assert registry.get(tab.leader_id) is None
-    assert registry.get(left.id) is None
-    assert registry.get(right.id) is None
-
-
-def test_delete_tab_tool_rejects_non_assistant():
-    agent = Agent(
-        NodeConfig(
-            node_type=NodeType.AGENT,
-            role_name="Worker",
-            tools=["delete_workflow"],
-        ),
-        uuid="worker",
-    )
-
-    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_edit_tool.py

@@ -1,115 +0,0 @@
-import json
-
-from flowent.agent import Agent
-from flowent.models import NodeConfig, NodeType
-from flowent.tools.edit import EditTool
-
-
-def test_edit_tool_applies_multiple_edits_in_sequence(tmp_path):
-    target = tmp_path / "sample.txt"
-    target.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
-    agent = Agent(
-        NodeConfig(
-            node_type=NodeType.AGENT,
-            tools=["edit"],
-            write_dirs=[str(tmp_path)],
-        )
-    )
-
-    result = json.loads(
-        EditTool().execute(
-            agent,
-            {
-                "path": str(target),
-                "edits": [
-                    {
-                        "start_line": 2,
-                        "end_line": 2,
-                        "new_content": "beta-1\nbeta-2\n",
-                    },
-                    {
-                        "start_line": 4,
-                        "end_line": 4,
-                        "new_content": "gamma-updated\n",
-                    },
-                ],
-            },
-        )
-    )
-
-    assert result["status"] == "edited"
-    assert (
-        target.read_text(encoding="utf-8") == "alpha\nbeta-1\nbeta-2\ngamma-updated\n"
-    )
-
-
-def test_edit_tool_creates_missing_file_with_edits(tmp_path):
-    target = tmp_path / "new.txt"
-    agent = Agent(
-        NodeConfig(
-            node_type=NodeType.AGENT,
-            tools=["edit"],
-            write_dirs=[str(tmp_path)],
-        )
-    )
-
-    result = json.loads(
-        EditTool().execute(
-            agent,
-            {
-                "path": str(target),
-                "edits": [
-                    {
-                        "start_line": 1,
-                        "end_line": 1,
-                        "new_content": "hello\nworld\n",
-                    }
-                ],
-            },
-        )
-    )
-
-    assert result["status"] == "edited"
-    assert target.read_text(encoding="utf-8") == "hello\nworld\n"
-
-
-def test_edit_tool_streams_progress_updates(tmp_path):
-    target = tmp_path / "sample.txt"
-    target.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
-    agent = Agent(
-        NodeConfig(
-            node_type=NodeType.AGENT,
-            tools=["edit"],
-            write_dirs=[str(tmp_path)],
-        )
-    )
-    chunks: list[str] = []
-
-    result = json.loads(
-        EditTool().execute(
-            agent,
-            {
-                "path": str(target),
-                "edits": [
-                    {
-                        "start_line": 2,
-                        "end_line": 2,
-                        "new_content": "beta-updated\n",
-                    },
-                    {
-                        "start_line": 3,
-                        "end_line": 3,
-                        "new_content": "gamma-updated\n",
-                    },
-                ],
-            },
-            on_output=chunks.append,
-        )
-    )
-
-    assert result["status"] == "edited"
-    assert "".join(chunks) == (
-        f"Applying edit 1/2 at lines 2-2\n"
-        f"Applying edit 2/2 at lines 3-3\n"
-        f"Wrote {target}\n"
-    )

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

@@ -1,81 +0,0 @@
-import json
-import shutil
-import subprocess
-
-import pytest
-
-from flowent.agent import Agent
-from flowent.models import NodeConfig, NodeType
-from flowent.settings import Settings
-from flowent.tools.exec import ExecTool
-
-
-def _sandbox_exec_supported(tmp_path) -> bool:
-    if shutil.which("bwrap") is None:
-        return False
-
-    probe = subprocess.run(
-        [
-            "bwrap",
-            "--ro-bind",
-            "/",
-            "/",
-            "--dev",
-            "/dev",
-            "--proc",
-            "/proc",
-            "--tmpfs",
-            "/tmp",
-            "--ro-bind",
-            str(tmp_path),
-            str(tmp_path),
-            "--chdir",
-            str(tmp_path),
-            "--die-with-parent",
-            "--new-session",
-            "--",
-            "bash",
-            "-c",
-            "pwd >/dev/null",
-        ],
-        capture_output=True,
-        text=True,
-    )
-    return probe.returncode == 0
-
-
-def test_exec_tool_runs_in_working_dir_when_tmp_is_sandboxed(
-    monkeypatch,
-    tmp_path,
-):
-    if not _sandbox_exec_supported(tmp_path):
-        pytest.skip("bwrap sandbox is unavailable in this environment")
-
-    target = tmp_path / "settings.json"
-    target.write_text('{"name": "demo"}\n', encoding="utf-8")
-    monkeypatch.setattr(
-        "flowent.settings.get_settings",
-        lambda: Settings(working_dir=str(tmp_path)),
-    )
-
-    agent = Agent(
-        NodeConfig(
-            node_type=NodeType.AGENT,
-            tools=["exec"],
-            write_dirs=[],
-        )
-    )
-
-    result = json.loads(
-        ExecTool().execute(
-            agent,
-            {
-                "command": "pwd; cat settings.json",
-                "timeout": 30,
-            },
-        )
-    )
-
-    assert result["returncode"] == 0
-    assert result["stdout"] == f"{tmp_path}\n" + '{"name": "demo"}\n'
-    assert result["stderr"] == ""

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

@@ -1,65 +0,0 @@
-import json
-
-from flowent.agent import Agent
-from flowent.models import NodeConfig, NodeType
-from flowent.tools.fetch import FetchTool
-
-
-class _FakeResponse:
-    def __init__(self, status_code: int, chunks: list[str]):
-        self.status_code = status_code
-        self._chunks = chunks
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc, tb):
-        return False
-
-    def iter_content(self):
-        for chunk in self._chunks:
-            yield chunk.encode()
-
-
-class _FakeClient:
-    last_impersonate_browser: bool | None = None
-
-    def __init__(self, *, timeout: float, impersonate_browser: bool = False):
-        self.timeout = timeout
-        self.impersonate_browser = impersonate_browser
-        type(self).last_impersonate_browser = impersonate_browser
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc, tb):
-        return False
-
-    def stream(self, method, url, headers=None, data=None):
-        assert method == "GET"
-        assert url == "https://example.com/data"
-        assert headers is None
-        assert data is None
-        return _FakeResponse(200, ["hello ", "world"])
-
-
-def test_fetch_tool_streams_response_body_chunks(monkeypatch):
-    agent = Agent(
-        NodeConfig(node_type=NodeType.AGENT, tools=["fetch"], allow_network=True)
-    )
-    chunks: list[str] = []
-    _FakeClient.last_impersonate_browser = None
-
-    monkeypatch.setattr("flowent.tools.fetch.create_http_session", _FakeClient)
-
-    result = json.loads(
-        FetchTool().execute(
-            agent,
-            {"method": "GET", "url": "https://example.com/data"},
-            on_output=chunks.append,
-        )
-    )
-
-    assert result == {"status_code": 200, "body": "hello world"}
-    assert "".join(chunks) == "GET https://example.com/data\nHTTP 200\n\nhello world"
-    assert _FakeClient.last_impersonate_browser is True

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

@@ -1,117 +0,0 @@
-import json
-
-from flowent.agent import Agent
-from flowent.models import NodeConfig, NodeType
-from flowent.settings import Settings
-from flowent.tools.manage_prompts import ManagePromptsTool
-
-
-def test_manage_prompts_get_returns_current_prompt(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
-    settings = Settings(
-        custom_prompt="Be concise.",
-        custom_post_prompt="Stay routed.",
-    )
-
-    monkeypatch.setattr("flowent.settings.get_settings", lambda: settings)
-
-    result = json.loads(ManagePromptsTool().execute(agent, {"action": "get"}))
-
-    assert result == {
-        "custom_prompt": "Be concise.",
-        "custom_post_prompt": "Stay routed.",
-    }
-
-
-def test_manage_prompts_update_saves_custom_prompt(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
-    settings = Settings(custom_prompt="", custom_post_prompt="")
-    saved: list[Settings] = []
-
-    monkeypatch.setattr("flowent.settings.get_settings", lambda: settings)
-    monkeypatch.setattr(
-        "flowent.settings.save_settings", lambda current: saved.append(current)
-    )
-
-    result = json.loads(
-        ManagePromptsTool().execute(
-            agent,
-            {
-                "action": "update",
-                "custom_prompt": "Always prefer terse answers.",
-                "custom_post_prompt": "Only route with @target.",
-            },
-        )
-    )
-
-    assert result == {
-        "custom_prompt": "Always prefer terse answers.",
-        "custom_post_prompt": "Only route with @target.",
-    }
-    assert settings.custom_prompt == "Always prefer terse answers."
-    assert settings.custom_post_prompt == "Only route with @target."
-    assert saved == [settings]
-
-
-def test_manage_prompts_update_requires_prompt_field(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
-    monkeypatch.setattr("flowent.settings.get_settings", lambda: Settings())
-
-    result = json.loads(
-        ManagePromptsTool().execute(
-            agent,
-            {"action": "update"},
-        )
-    )
-
-    assert result == {"error": "custom_prompt or custom_post_prompt is required"}
-
-
-def test_manage_prompts_update_allows_custom_post_prompt_only(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
-    settings = Settings(custom_prompt="Keep this.", custom_post_prompt="")
-
-    monkeypatch.setattr("flowent.settings.get_settings", lambda: settings)
-    monkeypatch.setattr("flowent.settings.save_settings", lambda current: None)
-
-    result = json.loads(
-        ManagePromptsTool().execute(
-            agent,
-            {
-                "action": "update",
-                "custom_post_prompt": "Append this after history.",
-            },
-        )
-    )
-
-    assert result == {
-        "custom_prompt": "Keep this.",
-        "custom_post_prompt": "Append this after history.",
-    }
-    assert settings.custom_prompt == "Keep this."
-    assert settings.custom_post_prompt == "Append this after history."
-
-
-def test_manage_prompts_update_accepts_legacy_post_prompt_alias(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
-    settings = Settings(custom_prompt="Keep this.", custom_post_prompt="")
-
-    monkeypatch.setattr("flowent.settings.get_settings", lambda: settings)
-    monkeypatch.setattr("flowent.settings.save_settings", lambda current: None)
-
-    result = json.loads(
-        ManagePromptsTool().execute(
-            agent,
-            {
-                "action": "update",
-                "post_prompt": "Append this after history.",
-            },
-        )
-    )
-
-    assert result == {
-        "custom_prompt": "Keep this.",
-        "custom_post_prompt": "Append this after history.",
-    }
-    assert settings.custom_prompt == "Keep this."
-    assert settings.custom_post_prompt == "Append this after history."