flowent 0.0.1 → 0.0.5

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

@@ -0,0 +1,152 @@
+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
+
+
+def _append_stream_chunk(
+    buffer: list[str],
+    size: int,
+    text: str,
+    on_output: Callable[[str], None] | None,
+) -> int:
+    if on_output is None or not text:
+        return size
+    buffer.append(text)
+    size += len(text)
+    if size >= 2048:
+        on_output("".join(buffer))
+        buffer.clear()
+        return 0
+    return size
+
+
+def _flush_stream_chunk(
+    buffer: list[str], on_output: Callable[[str], None] | None
+) -> None:
+    if on_output is None or not buffer:
+        return
+    on_output("".join(buffer))
+    buffer.clear()
+
+
+class ReadTool(Tool):
+    name = "read"
+    description = (
+        "Read a file with line numbers, or list a directory. "
+        "Use start_line and end_line to read a specific range (1-indexed, inclusive). "
+        "Line numbers in the output are used as input to the edit tool."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "path": {
+                "type": "string",
+                "description": "Absolute path to the file or directory to read",
+            },
+            "start_line": {
+                "type": "integer",
+                "description": "First line to read (1-indexed, inclusive). Defaults to 1.",
+            },
+            "end_line": {
+                "type": "integer",
+                "description": "Last line to read (1-indexed, inclusive). Defaults to end of file.",
+            },
+        },
+        "required": ["path"],
+    }
+
+    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")
+
+        if real_path.is_dir():
+            try:
+                entries = []
+                stream_buffer: list[str] = []
+                stream_size = 0
+                for entry in sorted(os.listdir(real_path)):
+                    full = real_path / entry
+                    kind = "dir" if full.is_dir() else "file"
+                    size = full.stat().st_size if kind == "file" else None
+                    entries.append({"name": entry, "type": kind, "size": size})
+                    label = f"{kind}\t{entry}"
+                    if size is not None:
+                        label = f"{label}\t{size}"
+                    stream_size = _append_stream_chunk(
+                        stream_buffer,
+                        stream_size,
+                        f"{label}\n",
+                        on_output,
+                    )
+                _flush_stream_chunk(stream_buffer, on_output)
+                logger.debug(
+                    "Listed directory: {} ({} entries)", path_str, len(entries)
+                )
+                return json.dumps({"path": path_str, "entries": entries})
+            except Exception as e:
+                re_raise_interrupt(agent, e)
+                return json.dumps({"error": str(e)})
+
+        if real_path.is_file():
+            try:
+                with open(real_path, encoding="utf-8") as f:
+                    total_lines = sum(1 for _ in f)
+
+                start = max(1, int(args.get("start_line", 1)))
+                end = min(total_lines, int(args.get("end_line", total_lines)))
+                width = max(6, len(str(total_lines)))
+                selected_parts: list[str] = []
+                stream_buffer = []
+                stream_size = 0
+
+                with open(real_path, encoding="utf-8") as f:
+                    for line_number, line in enumerate(f, start=1):
+                        if line_number < start:
+                            continue
+                        if line_number > end:
+                            break
+                        numbered_line = f"{line_number:{width}d}\t{line}"
+                        selected_parts.append(numbered_line)
+                        stream_size = _append_stream_chunk(
+                            stream_buffer,
+                            stream_size,
+                            numbered_line,
+                            on_output,
+                        )
+
+                _flush_stream_chunk(stream_buffer, on_output)
+                numbered = "".join(selected_parts)
+
+                logger.debug(
+                    "Read file: {} (lines {}-{} of {})",
+                    path_str,
+                    start,
+                    end,
+                    total_lines,
+                )
+                return json.dumps(
+                    {
+                        "path": path_str,
+                        "total_lines": total_lines,
+                        "start_line": start,
+                        "end_line": end,
+                        "content": numbered,
+                    }
+                )
+            except Exception as e:
+                re_raise_interrupt(agent, e)
+                return json.dumps({"error": str(e)})
+
+        return json.dumps({"error": f"Not found: {path_str}"})

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

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.tools import Tool
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class SendTool(Tool):
+    name = "send"
+    description = "Send to one current contact or output-port path."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "target": {
+                "type": "string",
+                "description": "One target id, name, or unique short id from contacts.",
+            },
+            "from_output_port_key": {
+                "type": "string",
+                "description": "Source output port key for workflow path sends.",
+            },
+            "to_input_port_key": {
+                "type": "string",
+                "description": "Target input port key for workflow path sends.",
+            },
+            "value": {
+                "description": "Typed value for workflow path sends. Use ordered parts for parts ports, a string for string ports, or an object for json ports.",
+            },
+            "parts": {
+                "type": "array",
+                "description": "Ordered message parts for Assistant and Leader entry contacts.",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "type": {"type": "string", "enum": ["text", "image"]},
+                        "text": {"type": "string"},
+                        "asset_id": {"type": "string"},
+                        "mime_type": {"type": "string"},
+                        "width": {"type": "integer"},
+                        "height": {"type": "integer"},
+                        "alt": {"type": "string"},
+                    },
+                    "required": ["type"],
+                },
+            },
+        },
+        "required": ["target"],
+        "additionalProperties": False,
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        target = args.get("target")
+        if not isinstance(target, str) or not target.strip():
+            raise ValueError("send.target must be a non-empty string")
+        if not agent._is_entry_level_sender():
+            return agent.send_port_value(
+                target_ref=target.strip(),
+                from_output_port_key=args.get("from_output_port_key"),
+                to_input_port_key=args.get("to_input_port_key"),
+                raw_value=args.get("value", args.get("parts")),
+            )
+        return agent.send_message(
+            target_ref=target.strip(),
+            raw_parts=args.get("parts"),
+        )

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

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.models import NodeType
+from flowent.tools import Tool
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class SetPermissionsTool(Tool):
+    name = "set_permissions"
+    description = (
+        "Update a workflow's permission boundary by patching its allow_network "
+        "and write_dirs."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "workflow_id": {
+                "type": "string",
+                "description": "ID of the workflow whose permission boundary should be updated",
+            },
+            "allow_network": {
+                "type": "boolean",
+                "description": "Optional patched network permission for the workflow boundary",
+            },
+            "write_dirs": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Optional patched writable directory boundary for the workflow",
+            },
+        },
+        "required": ["workflow_id"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        from flowent.graph_service import (
+            resolve_effective_permissions_for_agent,
+            set_tab_permissions,
+        )
+        from flowent.settings import (
+            build_assistant_allow_network,
+            build_assistant_write_dirs,
+        )
+
+        workflow_id = args.get("workflow_id")
+        raw_allow_network = args.get("allow_network")
+        raw_write_dirs = args.get("write_dirs")
+
+        if not isinstance(workflow_id, str) or not workflow_id.strip():
+            return json.dumps({"error": "workflow_id must be a non-empty string"})
+        normalized_workflow_id = workflow_id.strip()
+        if (
+            agent.node_type != NodeType.ASSISTANT
+            and agent.config.tab_id != normalized_workflow_id
+        ):
+            return json.dumps(
+                {"error": "Workflow permissions can only be changed for this workflow"}
+            )
+
+        allow_network: bool | None = None
+        if "allow_network" in args:
+            try:
+                allow_network = build_assistant_allow_network(
+                    raw_allow_network,
+                    field_name="allow_network",
+                )
+            except ValueError as exc:
+                return json.dumps({"error": str(exc)})
+
+        write_dirs: list[str] | None = None
+        if "write_dirs" in args:
+            try:
+                write_dirs = build_assistant_write_dirs(
+                    raw_write_dirs,
+                    field_name="write_dirs",
+                )
+            except ValueError as exc:
+                return json.dumps({"error": str(exc)})
+
+        caller_allow_network, caller_write_dirs = (
+            resolve_effective_permissions_for_agent(agent)
+        )
+        result, error = set_tab_permissions(
+            tab_id=normalized_workflow_id,
+            allow_network=allow_network,
+            write_dirs=write_dirs,
+            caller_allow_network=caller_allow_network,
+            caller_write_dirs=caller_write_dirs,
+            actor_id=agent.uuid,
+        )
+        if error is not None or result is None:
+            return json.dumps(
+                {"error": error or "Failed to update workflow permissions"}
+            )
+        return json.dumps(result)

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

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+from math import isfinite
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.tools import Tool
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class SleepTool(Tool):
+    name = "sleep"
+    description = (
+        "Enter a timed wait that resumes on whichever happens first: a new input "
+        "arrives or the requested duration elapses. Use this when you want to wait "
+        "until a deadline without missing messages."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "seconds": {
+                "type": "number",
+                "description": "How many seconds to wait before resuming execution. Supports fractional seconds.",
+                "minimum": 0,
+            }
+        },
+        "required": ["seconds"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        seconds = args.get("seconds")
+        if isinstance(seconds, bool) or not isinstance(seconds, int | float):
+            return json.dumps({"error": "seconds must be a non-negative number"})
+
+        duration = float(seconds)
+        if not isfinite(duration) or duration < 0:
+            return json.dumps({"error": "seconds must be a non-negative number"})
+
+        return agent.request_sleep(seconds=duration)

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

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.events import event_bus
+from flowent.models import Event, EventType, TodoItem
+from flowent.tools import Tool
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class TodoTool(Tool):
+    name = "todo"
+    description = "Replace the full todo list with a new ordered list of task strings."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "todos": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Complete replacement todo list. Pass an empty array to clear all todos.",
+            },
+        },
+        "required": ["todos"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        raw_todos = args["todos"]
+        if not isinstance(raw_todos, list) or not all(
+            isinstance(item, str) for item in raw_todos
+        ):
+            return json.dumps({"error": "todos must be an array of strings"})
+
+        next_todos = [TodoItem(text=item) for item in raw_todos]
+        agent.set_todos(next_todos)
+        self._emit_todo_event(agent)
+        return json.dumps({"status": "updated"})
+
+    @staticmethod
+    def _emit_todo_event(agent: Agent) -> None:
+        event_bus.emit(
+            Event(
+                type=EventType.NODE_TODOS_CHANGED,
+                agent_id=agent.uuid,
+                data={
+                    "todos": [t.serialize() for t in agent.get_todos_snapshot()],
+                },
+            ),
+        )