flowent 0.0.6 → 0.0.10

package/backend/src/flowent/static/favicon.svg

@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
-  <rect width="64" height="64" rx="12" fill="#111111" />
-  <path fill="#ffffff" d="M18 16h31v8H27v10h18v8H27v16h-9z" />
-</svg>

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

@@ -1,275 +0,0 @@
-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/connect.py

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

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

@@ -1,191 +0,0 @@
-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())