flowent 0.0.0 → 0.0.4

package/backend/src/flowent/tools/contacts.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.tools import Tool
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class ContactsTool(Tool):
+    name = "contacts"
+    description = "List the agents this node can message directly right now."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        return json.dumps({"contacts": agent.get_contacts_info()})

package/backend/src/flowent/tools/create_agent.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.graph_service import create_agent_node
+from flowent.models import NodeType
+from flowent.settings import build_assistant_write_dirs, resolve_path
+from flowent.tools import Tool
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class CreateAgentTool(Tool):
+    name = "create_agent"
+    description = "Create a new agent node inside your current workflow."
+    parameters: ClassVar[dict[str, Any]] = {
+        "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",
+            },
+            "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"],
+                "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"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        if "workflow_id" in args or "tab_id" in args:
+            return json.dumps({"error": "create_agent does not accept workflow_id"})
+        if "connect_to_creator" in args:
+            return json.dumps(
+                {
+                    "error": "create_agent no longer supports connect_to_creator; use placement"
+                }
+            )
+        role_name = args.get("role_name")
+        name = args.get("name")
+        tools = args.get("tools", [])
+        write_dirs = args.get("write_dirs", [])
+        allow_network = args.get("allow_network", False)
+        placement = args.get("placement", "standalone")
+        after_node_id = args.get("after_node_id")
+        between_from_node_id = args.get("between_from_node_id")
+        between_to_node_id = args.get("between_to_node_id")
+
+        if not isinstance(role_name, str) or not role_name.strip():
+            return json.dumps({"error": "role_name must be a non-empty string"})
+        if name is not None and not isinstance(name, str):
+            return json.dumps({"error": "name must be a string"})
+        if not isinstance(tools, list) or not all(
+            isinstance(item, str) for item in tools
+        ):
+            return json.dumps({"error": "tools must be an array of strings"})
+        if not isinstance(write_dirs, list) or not all(
+            isinstance(item, str) for item in write_dirs
+        ):
+            return json.dumps({"error": "write_dirs must be an array of strings"})
+        if not isinstance(allow_network, bool):
+            return json.dumps({"error": "allow_network must be a boolean"})
+        if placement not in {"standalone", "after", "between"}:
+            return json.dumps(
+                {"error": "placement must be standalone, after, or between"}
+            )
+        if after_node_id is not None and not isinstance(after_node_id, str):
+            return json.dumps({"error": "after_node_id must be a string"})
+        if between_from_node_id is not None and not isinstance(
+            between_from_node_id, str
+        ):
+            return json.dumps({"error": "between_from_node_id must be a string"})
+        if between_to_node_id is not None and not isinstance(between_to_node_id, str):
+            return json.dumps({"error": "between_to_node_id must be a string"})
+        try:
+            write_dirs = build_assistant_write_dirs(
+                write_dirs,
+                field_name="write_dirs",
+            )
+        except ValueError as exc:
+            return json.dumps({"error": str(exc)})
+        normalized_role_name = role_name.strip()
+        if agent.node_type == NodeType.ASSISTANT:
+            return json.dumps(
+                {"error": "Assistant may not create ordinary task nodes directly"}
+            )
+        if not agent.config.tab_id:
+            return json.dumps(
+                {
+                    "error": "Only a node inside a workflow may create ordinary task nodes"
+                }
+            )
+        if "create_agent" not in agent.config.tools:
+            return json.dumps({"error": "create_agent is not enabled for this node"})
+        from flowent.graph_service import get_tab_leader_id
+
+        leader_id = get_tab_leader_id(agent.config.tab_id)
+        if leader_id is None:
+            return json.dumps(
+                {"error": "Current workflow does not have a bound Leader"}
+            )
+        from flowent.registry import registry
+        from flowent.workspace_store import workspace_store
+
+        leader = registry.get(leader_id)
+        leader_record = workspace_store.get_node_record(leader_id)
+        leader_config = (
+            agent.config
+            if agent.uuid == leader_id
+            else (
+                leader.config
+                if leader is not None
+                else (leader_record.config if leader_record is not None else None)
+            )
+        )
+        if leader is None and leader_record is None:
+            return json.dumps({"error": f"Leader '{leader_id}' was not found"})
+        leader_write_dirs_source = (
+            leader_config.write_dirs if leader_config is not None else []
+        )
+        leader_allow_network = (
+            leader_config.allow_network if leader_config is not None else False
+        )
+
+        parent_write_dirs = [resolve_path(path) for path in agent.config.write_dirs]
+        invalid_write_dirs = sorted(
+            path
+            for path in write_dirs
+            if not any(
+                resolve_path(path).is_relative_to(parent_path)
+                for parent_path in parent_write_dirs
+            )
+        )
+        if invalid_write_dirs:
+            return json.dumps(
+                {
+                    "error": "write_dirs boundary exceeded: "
+                    + ", ".join(invalid_write_dirs)
+                }
+            )
+        if allow_network and not agent.config.allow_network:
+            return json.dumps(
+                {
+                    "error": "allow_network boundary exceeded: parent disallows network access"
+                }
+            )
+        leader_write_dirs = [resolve_path(path) for path in leader_write_dirs_source]
+        leader_invalid_write_dirs = sorted(
+            path
+            for path in write_dirs
+            if not any(
+                resolve_path(path).is_relative_to(parent_path)
+                for parent_path in leader_write_dirs
+            )
+        )
+        if leader_invalid_write_dirs:
+            return json.dumps(
+                {
+                    "error": "write_dirs boundary exceeded: "
+                    + ", ".join(leader_invalid_write_dirs)
+                }
+            )
+        if allow_network and not leader_allow_network:
+            return json.dumps(
+                {
+                    "error": "allow_network boundary exceeded: workflow Leader disallows network access"
+                }
+            )
+
+        record, error = create_agent_node(
+            role_name=normalized_role_name,
+            tab_id=agent.config.tab_id,
+            name=name,
+            tools=tools,
+            write_dirs=write_dirs,
+            allow_network=allow_network,
+        )
+        if error is not None or record is None:
+            return json.dumps({"error": error or "Failed to create agent"})
+        if placement == "after":
+            if not isinstance(after_node_id, str) or not after_node_id.strip():
+                return json.dumps(
+                    {"error": "after_node_id is required when placement=after"}
+                )
+            from flowent.graph_service import create_edge
+
+            edge, edge_error = create_edge(
+                tab_id=agent.config.tab_id,
+                from_node_id=after_node_id,
+                to_node_id=record.id,
+            )
+            if edge_error is not None or edge is None:
+                return json.dumps({"error": edge_error or "Failed to place agent"})
+        elif placement == "between":
+            if (
+                not isinstance(between_from_node_id, str)
+                or not between_from_node_id.strip()
+            ):
+                return json.dumps(
+                    {"error": "between_from_node_id is required when placement=between"}
+                )
+            if (
+                not isinstance(between_to_node_id, str)
+                or not between_to_node_id.strip()
+            ):
+                return json.dumps(
+                    {"error": "between_to_node_id is required when placement=between"}
+                )
+            from flowent.graph_service import create_edge, delete_edge
+
+            deleted, delete_error = delete_edge(
+                tab_id=agent.config.tab_id,
+                from_node_id=between_from_node_id,
+                to_node_id=between_to_node_id,
+            )
+            if delete_error is not None or deleted is None:
+                return json.dumps({"error": delete_error or "Failed to place agent"})
+            first_edge, first_error = create_edge(
+                tab_id=agent.config.tab_id,
+                from_node_id=between_from_node_id,
+                to_node_id=record.id,
+            )
+            if first_error is not None or first_edge is None:
+                return json.dumps({"error": first_error or "Failed to place agent"})
+            second_edge, second_error = create_edge(
+                tab_id=agent.config.tab_id,
+                from_node_id=record.id,
+                to_node_id=between_to_node_id,
+            )
+            if second_error is not None or second_edge is None:
+                return json.dumps({"error": second_error or "Failed to place agent"})
+        return json.dumps(record.serialize())

package/backend/src/flowent/tools/create_tab.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.graph_service import create_tab, serialize_tab_summary
+from flowent.tools import Tool
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class CreateTabTool(Tool):
+    name = "create_workflow"
+    description = (
+        "Create a new workflow with its bound Leader and empty Workflow Graph."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "title": {
+                "type": "string",
+                "description": "Human-readable workflow title",
+            },
+            "allow_network": {
+                "type": "boolean",
+                "description": "Whether the workflow's leader should have network access (default False)",
+            },
+            "write_dirs": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of directory paths the workflow's leader is allowed to write to",
+            },
+        },
+        "required": ["title"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        title = args.get("title")
+        allow_network = args.get("allow_network", False)
+        write_dirs = args.get("write_dirs", [])
+        if not isinstance(title, str) or not title.strip():
+            return json.dumps({"error": "title must be a non-empty string"})
+        if not isinstance(allow_network, bool):
+            return json.dumps({"error": "allow_network must be a boolean"})
+        if not isinstance(write_dirs, list) or not all(
+            isinstance(x, str) for x in write_dirs
+        ):
+            return json.dumps({"error": "write_dirs must be a list of strings"})
+
+        try:
+            tab = create_tab(
+                title=title,
+                allow_network=allow_network,
+                write_dirs=write_dirs,
+            )
+        except ValueError as exc:
+            return json.dumps({"error": str(exc)})
+        return json.dumps(serialize_tab_summary(tab))

package/backend/src/flowent/tools/delete_tab.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.graph_service import delete_tab
+from flowent.models import NodeType
+from flowent.tools import Tool
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class DeleteTabTool(Tool):
+    name = "delete_workflow"
+    description = "Delete a workflow and clean up its graph."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "workflow_id": {
+                "type": "string",
+                "description": "ID of the workflow to delete",
+            }
+        },
+        "required": ["workflow_id"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        if agent.node_type != NodeType.ASSISTANT:
+            return json.dumps({"error": "Only the Assistant may delete workflows"})
+
+        workflow_id = args.get("workflow_id")
+        if not isinstance(workflow_id, str) or not workflow_id.strip():
+            return json.dumps({"error": "workflow_id must be a non-empty string"})
+
+        deleted, error = delete_tab(tab_id=workflow_id.strip())
+        if error is not None or deleted is None:
+            return json.dumps({"error": error or "Failed to delete workflow"})
+        return json.dumps(deleted)

package/backend/src/flowent/tools/edit.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from loguru import logger
+
+from flowent.tools import Tool, re_raise_interrupt
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class EditTool(Tool):
+    name = "edit"
+    description = (
+        "Apply one or more line-based edits to a file in order. "
+        "Use the read tool first to get the exact line numbers. "
+        "Each edit uses 1-indexed inclusive start_line and end_line. "
+        "new_content replaces those lines exactly as given (include a trailing newline if needed). "
+        "If the file does not exist it will be created."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "path": {
+                "type": "string",
+                "description": "Absolute path to the file to edit or create",
+            },
+            "edits": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "start_line": {
+                            "type": "integer",
+                            "description": "First line to replace (1-indexed, inclusive). Use 1 for a new file.",
+                        },
+                        "end_line": {
+                            "type": "integer",
+                            "description": "Last line to replace (1-indexed, inclusive).",
+                        },
+                        "new_content": {
+                            "type": "string",
+                            "description": "Replacement text for the specified line range. Use an empty string to delete lines.",
+                        },
+                    },
+                    "required": ["start_line", "end_line", "new_content"],
+                },
+                "description": "Edits to apply in order. Later line numbers are based on the file state after earlier edits.",
+            },
+        },
+        "required": ["path", "edits"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **kwargs: Any) -> str:
+        path_str = args["path"]
+        real_path = Path(path_str)
+        on_output: Callable[[str], None] | None = kwargs.get("on_output")
+
+        try:
+            edits = args["edits"]
+            if not isinstance(edits, list):
+                return json.dumps({"error": "edits must be an array"})
+
+            if not real_path.exists():
+                os.makedirs(real_path.parent, exist_ok=True)
+                real_path.write_text("", encoding="utf-8")
+                if on_output is not None:
+                    on_output(f"Created {path_str}\n")
+
+            with open(real_path, encoding="utf-8") as f:
+                lines = f.readlines()
+
+            applied_edits: list[dict[str, int | str]] = []
+            for index, raw_edit in enumerate(edits, start=1):
+                if not isinstance(raw_edit, dict):
+                    return json.dumps({"error": "each edit must be an object"})
+
+                start_line = int(raw_edit["start_line"])
+                end_line = int(raw_edit["end_line"])
+                new_content: str = raw_edit["new_content"]
+
+                if start_line < 1:
+                    return json.dumps({"error": "start_line must be >= 1"})
+                if end_line < start_line:
+                    return json.dumps({"error": "end_line must be >= start_line"})
+
+                total_lines = len(lines)
+                if start_line > total_lines + 1:
+                    return json.dumps(
+                        {
+                            "error": f"start_line {start_line} exceeds file length {total_lines}"
+                        }
+                    )
+
+                current_end_line = min(end_line, total_lines)
+                if on_output is not None:
+                    on_output(
+                        f"Applying edit {index}/{len(edits)} at lines {start_line}-{current_end_line}\n"
+                    )
+
+                replacement = []
+                if new_content:
+                    replacement = new_content.splitlines(keepends=True)
+                    if replacement and not replacement[-1].endswith("\n"):
+                        replacement[-1] += "\n"
+
+                lines = lines[: start_line - 1] + replacement + lines[current_end_line:]
+                applied_edits.append(
+                    {
+                        "start_line": start_line,
+                        "end_line": current_end_line,
+                        "replacement_line_count": len(replacement),
+                    }
+                )
+
+            with open(real_path, "w", encoding="utf-8") as f:
+                f.writelines(lines)
+            if on_output is not None:
+                on_output(f"Wrote {path_str}\n")
+
+            logger.debug(
+                "Edited file: {} ({} edit(s), new_line_count={})",
+                path_str,
+                len(applied_edits),
+                len(lines),
+            )
+            return json.dumps(
+                {
+                    "status": "edited",
+                    "path": path_str,
+                    "applied_edits": applied_edits,
+                    "new_line_count": len(lines),
+                }
+            )
+        except Exception as e:
+            re_raise_interrupt(agent, e)
+            return json.dumps({"error": str(e)})

package/backend/src/flowent/tools/exec.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import threading
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from loguru import logger
+
+from flowent.sandbox import build_bwrap_cmd
+from flowent.tools import Tool, re_raise_interrupt
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class ExecTool(Tool):
+    name = "exec"
+    description = "Execute a shell command in a sandboxed environment."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "command": {
+                "type": "string",
+                "description": "Shell command to execute",
+            },
+            "timeout": {
+                "type": "number",
+                "description": "Timeout in seconds (default 30)",
+            },
+        },
+        "required": ["command"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **kwargs: Any) -> str:
+        on_output: Callable[[str], None] | None = kwargs.get("on_output")
+        from flowent.settings import get_runtime_working_dir_path
+
+        command = args["command"]
+        timeout = int(args.get("timeout", 30))
+        write_dirs = agent.config.write_dirs
+        cwd = Path(get_runtime_working_dir_path())
+
+        bwrap_cmd = build_bwrap_cmd(
+            write_dirs,
+            command,
+            allow_network=agent.config.allow_network,
+            cwd=cwd,
+        )
+
+        logger.debug(
+            "Executing command: {} (timeout={}s, cwd={})",
+            command,
+            timeout,
+            cwd,
+        )
+
+        proc: subprocess.Popen[str] | None = None
+        try:
+            proc = subprocess.Popen(
+                bwrap_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                cwd=str(cwd),
+            )
+            agent.set_interrupt_callback(
+                lambda: proc.kill() if proc.poll() is None else None
+            )
+
+            stdout_lines: list[str] = []
+            stderr_lines: list[str] = []
+
+            def _read_stderr() -> None:
+                assert proc.stderr is not None
+                for line in proc.stderr:
+                    stderr_lines.append(line)
+
+            stderr_thread = threading.Thread(target=_read_stderr, daemon=True)
+            stderr_thread.start()
+
+            assert proc.stdout is not None
+            for line in proc.stdout:
+                stdout_lines.append(line)
+                if on_output:
+                    on_output(line)
+
+            try:
+                proc.wait(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait()
+                logger.warning("Command timed out after {}s: {}", timeout, command)
+                return json.dumps({"error": f"Command timed out after {timeout}s"})
+
+            stderr_thread.join(timeout=5)
+
+            stdout = "".join(stdout_lines)
+            stderr = "".join(stderr_lines)
+            logger.debug("Command exited with code {}", proc.returncode)
+            return json.dumps(
+                {
+                    "returncode": proc.returncode,
+                    "stdout": stdout[:5000],
+                    "stderr": stderr[:2000],
+                }
+            )
+        except Exception as e:
+            if proc is not None and proc.poll() is None:
+                proc.kill()
+                proc.wait()
+            re_raise_interrupt(agent, e)
+            return json.dumps({"error": str(e)})
+        finally:
+            agent.set_interrupt_callback(None)