flowent 0.0.6 → 0.0.10

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

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

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

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

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

@@ -1,51 +0,0 @@
-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()],
-                },
-            ),
-        )