npm - flowent - Versions diffs - 0.0.1 → 0.0.5 - Mend

flowent 0.0.1 → 0.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (484) hide show

package/backend/src/flowent/static/index.html ADDED Viewed

@@ -0,0 +1,35 @@
+<!doctype html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Flowent</title>
+    <meta name="description" content="Flowent application" />
+    <script>
+      (() => {
+        try {
+          const storedTheme = window.localStorage.getItem("flowent-theme");
+          const theme = storedTheme === "light" ? "light" : "dark";
+          const root = document.documentElement;
+          root.classList.toggle("dark", theme === "dark");
+          root.classList.toggle("light", theme === "light");
+          root.style.colorScheme = theme;
+        } catch {
+          document.documentElement.classList.add("dark");
+          document.documentElement.style.colorScheme = "dark";
+        }
+      })();
+    </script>
+    <script type="module" crossorigin src="/assets/index-Biio-CoI.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-BYbx6iT9.js">
+    <link rel="modulepreload" crossorigin href="/assets/graph-vendor-DRq_-6fV.js">
+    <link rel="modulepreload" crossorigin href="/assets/react-vendor-mEs_JJxa.js">
+    <link rel="modulepreload" crossorigin href="/assets/ui-vendor-UazN8rcv.js">
+    <link rel="stylesheet" crossorigin href="/assets/graph-vendor-CHpVij2M.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-CmQvO7sl.css">
+  </head>
+  <body class="min-h-dvh bg-background text-foreground">
+    <div id="root"></div>
+  </body>
+</html>

package/backend/src/flowent/tools/__init__.py ADDED Viewed

@@ -0,0 +1,275 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+if TYPE_CHECKING:
+    from typing import ClassVar
+    from flowent.agent import Agent
+MINIMUM_TOOLS = (
+    "idle",
+    "sleep",
+    "todo",
+    "contacts",
+    "send",
+)
+MCP_BROWSING_TOOLS = (
+    "list_mcp_resources",
+    "list_mcp_resource_templates",
+    "read_mcp_resource",
+    "list_mcp_prompts",
+    "get_mcp_prompt",
+)
+ASSISTANT_ONLY_TOOLS = frozenset(
+    {
+        "create_workflow",
+        "delete_workflow",
+        "list_workflows",
+        "manage_providers",
+        "manage_roles",
+        "manage_settings",
+        "manage_prompts",
+    }
+)
+ASSISTANT_ONLY_MCP_TOOL_NAMES = frozenset(
+    {
+        "create_workflow",
+        "create_workflows",
+        "delete_workflow",
+        "delete_workflows",
+        "duplicate_workflow",
+        "duplicate_workflows",
+        "copy_workflow",
+        "copy_workflows",
+        "list_workflow",
+        "list_workflows",
+        "select_workflow",
+        "select_workflows",
+        "switch_workflow",
+        "switch_workflows",
+        "manage_provider",
+        "manage_providers",
+        "manage_role",
+        "manage_roles",
+        "manage_setting",
+        "manage_settings",
+        "manage_prompt",
+        "manage_prompts",
+    }
+)
+def is_assistant_only_tool_name(tool_name: str) -> bool:
+    return tool_name in ASSISTANT_ONLY_TOOLS
+def is_assistant_only_mcp_tool_name(tool_name: str) -> bool:
+    normalized = tool_name.strip().lower().replace("-", "_")
+    candidate = (
+        normalized.rsplit("__", 1)[-1] if normalized.startswith("mcp__") else normalized
+    )
+    return (
+        normalized in ASSISTANT_ONLY_MCP_TOOL_NAMES
+        or candidate in ASSISTANT_ONLY_MCP_TOOL_NAMES
+    )
+class Tool(ABC):
+    name: str
+    description: str
+    parameters: ClassVar[dict[str, Any]]
+    agent_visible: ClassVar[bool] = True
+    llm_visible: ClassVar[bool] = True
+    @abstractmethod
+    def execute(
+        self, agent: Agent, args: dict[str, Any], **kwargs: Any
+    ) -> str | None: ...
+    def to_schema(self) -> dict[str, Any]:
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }
+def re_raise_interrupt(agent: Agent, exc: BaseException) -> None:
+    from flowent.agent import InterruptRequestedError
+    if isinstance(exc, InterruptRequestedError) or agent.is_interrupt_requested():
+        raise InterruptRequestedError() from exc
+class ToolRegistry:
+    def __init__(self) -> None:
+        self._tools: dict[str, Tool] = {}
+    def register(self, tool: Tool) -> None:
+        self._tools[tool.name] = tool
+    def get(self, name: str) -> Tool | None:
+        tool = self._tools.get(name)
+        if tool is not None:
+            return tool
+        from flowent.mcp_service import mcp_service
+        from flowent.tools.mcp import DynamicMCPTool
+        descriptor = mcp_service.get_dynamic_tool_descriptor(name)
+        if descriptor is None:
+            return None
+        return DynamicMCPTool(descriptor=descriptor)
+    def list_tools(self, *, agent_visible_only: bool = False) -> list[Tool]:
+        tools = list(self._tools.values())
+        from flowent.mcp_service import mcp_service
+        from flowent.tools.mcp import DynamicMCPTool
+        dynamic_tools = [
+            DynamicMCPTool(descriptor=descriptor)
+            for descriptor in mcp_service.list_discovered_tools()
+        ]
+        tools.extend(dynamic_tools)
+        if not agent_visible_only:
+            return tools
+        return [tool for tool in tools if tool.agent_visible]
+    def get_tools_for_agent(self, agent: Agent) -> list[Tool]:
+        from flowent.mcp_service import mcp_service
+        from flowent.models import NodeType
+        from flowent.settings import find_role, get_settings
+        from flowent.tools.mcp import DynamicMCPTool
+        allowed = set(agent.config.tools) | set(MINIMUM_TOOLS)
+        if agent.node_type != NodeType.ASSISTANT:
+            allowed -= ASSISTANT_ONLY_TOOLS
+        visible_tools = [
+            t for t in self._tools.values() if t.name in allowed and t.llm_visible
+        ]
+        role = find_role(get_settings(), agent.config.role_name or "")
+        excluded = set(role.excluded_tools) if role is not None else set()
+        dynamic_tools = [
+            DynamicMCPTool(descriptor=descriptor)
+            for descriptor in mcp_service.list_agent_dynamic_tools(agent)
+            if descriptor.fully_qualified_id in allowed
+            and descriptor.fully_qualified_id not in excluded
+            and (
+                agent.node_type == NodeType.ASSISTANT
+                or not is_assistant_only_mcp_tool_name(descriptor.tool_name)
+            )
+        ]
+        return [*visible_tools, *dynamic_tools]
+    def get_tools_schema(self, agent: Agent) -> list[dict[str, Any]]:
+        return [t.to_schema() for t in self.get_tools_for_agent(agent)]
+def build_tool_registry() -> ToolRegistry:
+    from flowent.tools.connect import ConnectTool
+    from flowent.tools.contacts import ContactsTool
+    from flowent.tools.create_agent import CreateAgentTool
+    from flowent.tools.create_tab import CreateTabTool
+    from flowent.tools.delete_tab import DeleteTabTool
+    from flowent.tools.edit import EditTool
+    from flowent.tools.exec import ExecTool
+    from flowent.tools.fetch import FetchTool
+    from flowent.tools.idle import IdleTool
+    from flowent.tools.list_roles import ListRolesTool
+    from flowent.tools.list_tabs import ListTabsTool
+    from flowent.tools.list_tools import ListToolsTool
+    from flowent.tools.manage_prompts import ManagePromptsTool
+    from flowent.tools.manage_providers import ManageProvidersTool
+    from flowent.tools.manage_roles import ManageRolesTool
+    from flowent.tools.manage_settings import ManageSettingsTool
+    from flowent.tools.mcp import (
+        GetMCPPromptTool,
+        ListMCPPromptsTool,
+        ListMCPResourcesTool,
+        ListMCPResourceTemplatesTool,
+        ReadMCPResourceTool,
+    )
+    from flowent.tools.read import ReadTool
+    from flowent.tools.send import SendTool
+    from flowent.tools.set_permissions import SetPermissionsTool
+    from flowent.tools.sleep import SleepTool
+    from flowent.tools.todo import TodoTool
+    reg = ToolRegistry()
+    for tool_cls in [
+        IdleTool,
+        SleepTool,
+        TodoTool,
+        ContactsTool,
+        SendTool,
+        CreateTabTool,
+        DeleteTabTool,
+        SetPermissionsTool,
+        CreateAgentTool,
+        ConnectTool,
+        ManageProvidersTool,
+        ManageRolesTool,
+        ManageSettingsTool,
+        ManagePromptsTool,
+        ReadTool,
+        EditTool,
+        ExecTool,
+        FetchTool,
+        ListRolesTool,
+        ListTabsTool,
+        ListToolsTool,
+        ListMCPResourcesTool,
+        ListMCPResourceTemplatesTool,
+        ReadMCPResourceTool,
+        ListMCPPromptsTool,
+        GetMCPPromptTool,
+    ]:
+        reg.register(tool_cls())  # type: ignore[abstract]
+    return reg
+def list_agent_visible_tool_descriptors(
+    *,
+    include_assistant_only: bool = True,
+) -> list[dict[str, Any]]:
+    registry = build_tool_registry()
+    from flowent.mcp_service import mcp_service
+    descriptors: list[dict[str, Any]] = []
+    for tool in registry.list_tools(agent_visible_only=True):
+        if tool.name.startswith("mcp__"):
+            continue
+        if not include_assistant_only and is_assistant_only_tool_name(tool.name):
+            continue
+        schema = tool.to_schema()
+        function = schema.get("function")
+        parameters = (
+            function.get("parameters")
+            if isinstance(function, dict)
+            else {"type": "object", "properties": {}, "required": []}
+        )
+        descriptors.append(
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "parameters": parameters,
+                "source": "builtin",
+            }
+        )
+    for descriptor in mcp_service.list_discovered_tool_descriptors():
+        tool_name = descriptor.get("tool_name")
+        if (
+            not include_assistant_only
+            and isinstance(tool_name, str)
+            and is_assistant_only_mcp_tool_name(tool_name)
+        ):
+            continue
+        descriptors.append(descriptor)
+    return descriptors

package/backend/src/flowent/tools/__pycache__/__init__.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/connect.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/contacts.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/create_agent.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/create_tab.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/delete_tab.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/edit.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/exec.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/fetch.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/idle.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/list_roles.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/list_tabs.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/list_tools.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/manage_prompts.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/manage_providers.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/manage_roles.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/manage_settings.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/mcp.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/read.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/send.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/set_permissions.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/sleep.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/__pycache__/todo.cpython-313.pyc ADDED Viewed

Binary file

package/backend/src/flowent/tools/connect.py ADDED Viewed

@@ -0,0 +1,100 @@
+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 ConnectTool(Tool):
+    name = "connect"
+    description = (
+        "Create a directed workflow edge between two nodes in the same workflow."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "from": {
+                "type": "string",
+                "description": "Source node UUID or name",
+            },
+            "to": {
+                "type": "string",
+                "description": "Target node UUID or name",
+            },
+            "from_port_key": {
+                "type": "string",
+                "description": "Source output port key",
+                "default": "out",
+            },
+            "to_port_key": {
+                "type": "string",
+                "description": "Target input port key",
+                "default": "in",
+            },
+        },
+        "required": ["from", "to"],
+    }
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        from flowent.graph_service import (
+            create_edge,
+            is_tab_leader,
+            resolve_workflow_node_ref,
+        )
+        from_ref = args.get("from")
+        to_ref = args.get("to")
+        from_port_key = args.get("from_port_key", "out")
+        to_port_key = args.get("to_port_key", "in")
+        if not isinstance(from_ref, str) or not from_ref:
+            return json.dumps({"error": "from must be a non-empty string"})
+        if not isinstance(to_ref, str) or not to_ref:
+            return json.dumps({"error": "to must be a non-empty string"})
+        if not isinstance(from_port_key, str) or not from_port_key.strip():
+            return json.dumps({"error": "from_port_key must be a non-empty string"})
+        if not isinstance(to_port_key, str) or not to_port_key.strip():
+            return json.dumps({"error": "to_port_key must be a non-empty string"})
+        if not agent.config.tab_id:
+            return json.dumps(
+                {"error": "Only a workflow Leader may connect task nodes"}
+            )
+        source_id = resolve_workflow_node_ref(
+            tab_id=agent.config.tab_id,
+            node_ref=from_ref,
+        )
+        target_id = resolve_workflow_node_ref(
+            tab_id=agent.config.tab_id,
+            node_ref=to_ref,
+        )
+        if source_id is None:
+            return json.dumps({"error": f"Node '{from_ref}' not found"})
+        if target_id is None:
+            return json.dumps({"error": f"Node '{to_ref}' not found"})
+        if agent.node_type == NodeType.ASSISTANT:
+            return json.dumps(
+                {"error": "Assistant may not rewire a Workflow Graph directly"}
+            )
+        if not is_tab_leader(node_id=agent.uuid, tab_id=agent.config.tab_id):
+            return json.dumps(
+                {"error": "Only a workflow Leader may connect task nodes"}
+            )
+        edge, error = create_edge(
+            tab_id=agent.config.tab_id,
+            from_node_id=source_id,
+            from_port_key=from_port_key,
+            to_node_id=target_id,
+            to_port_key=to_port_key,
+        )
+        if error is not None or edge is None:
+            return json.dumps({"error": error or "Failed to connect nodes"})
+        return json.dumps(edge.serialize())

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

@@ -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 current contacts and output-port paths."
+    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 ADDED Viewed

@@ -0,0 +1,191 @@
+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.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",
+            },
+            "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 "write_dirs" in args or "allow_network" in args:
+            return json.dumps(
+                {
+                    "error": (
+                        "create_agent uses the current workflow permissions; "
+                        "update the workflow permissions instead"
+                    )
+                }
+            )
+        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", [])
+        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 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"})
+        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)
+        if leader is None and leader_record is None:
+            return json.dumps({"error": f"Leader '{leader_id}' was not found"})
+        record, error = create_agent_node(
+            role_name=normalized_role_name,
+            tab_id=agent.config.tab_id,
+            name=name,
+            tools=tools,
+        )
+        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())