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

flowent 0.0.1 → 0.0.4

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 (493) hide show

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

@@ -0,0 +1,36 @@
+<!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-CL1ALZ3r.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-BYbx6iT9.js">
+    <link rel="modulepreload" crossorigin href="/assets/shared-CMxbpLeQ.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-Dg9NNnWX.js">
+    <link rel="stylesheet" crossorigin href="/assets/graph-vendor-CHpVij2M.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BHC1Vhy8.css">
+  </head>
+  <body class="min-h-dvh bg-background text-foreground">
+    <div id="root"></div>
+  </body>
+</html>

package/backend/src/flowent/stats_service.py ADDED Viewed

@@ -0,0 +1,218 @@
+from __future__ import annotations
+import copy
+import json
+import threading
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Any, Literal
+from flowent.models import LLMUsage
+from flowent.state_db import open_state_db
+MAX_STATS_RETENTION_SECONDS = 30 * 24 * 60 * 60
+def serialize_usage(usage: LLMUsage | None) -> dict[str, Any] | None:
+    if usage is None:
+        return None
+    return {
+        "total_tokens": usage.total_tokens,
+        "input_tokens": usage.input_tokens,
+        "output_tokens": usage.output_tokens,
+        "cached_input_tokens": usage.cached_input_tokens,
+        "cache_read_tokens": usage.cache_read_tokens,
+        "cache_write_tokens": usage.cache_write_tokens,
+        "details": dict(usage.details),
+    }
+@dataclass(frozen=True)
+class RequestRecordInput:
+    node_id: str
+    node_label: str
+    role_name: str | None
+    tab_id: str | None
+    tab_title: str | None
+    provider_id: str | None
+    provider_name: str | None
+    provider_type: str | None
+    model: str | None
+    started_at: float
+    ended_at: float
+    retry_count: int
+    result: Literal["success", "error"]
+    normalized_usage: LLMUsage | None = None
+    raw_usage: dict[str, Any] | None = None
+    error_summary: str | None = None
+@dataclass(frozen=True)
+class CompactRecordInput:
+    node_id: str
+    node_label: str
+    role_name: str | None
+    tab_id: str | None
+    tab_title: str | None
+    provider_id: str | None
+    provider_name: str | None
+    provider_type: str | None
+    model: str | None
+    trigger_type: Literal["manual", "auto"]
+    started_at: float
+    ended_at: float
+    result: Literal["success", "error"]
+    error_summary: str | None = None
+class StatsStore:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+    def reset(self) -> None:
+        connection = open_state_db(create=False)
+        if connection is None:
+            return
+        try:
+            with connection:
+                connection.execute("DELETE FROM llm_request_records")
+                connection.execute("DELETE FROM compact_records")
+        finally:
+            connection.close()
+    def _prune_locked(self, connection, now: float) -> None:
+        min_timestamp = now - MAX_STATS_RETENTION_SECONDS
+        connection.execute(
+            "DELETE FROM llm_request_records WHERE ended_at < ?",
+            (min_timestamp,),
+        )
+        connection.execute(
+            "DELETE FROM compact_records WHERE ended_at < ?",
+            (min_timestamp,),
+        )
+    def record_request(self, record: RequestRecordInput) -> None:
+        payload = {
+            "id": str(uuid.uuid4()),
+            "node_id": record.node_id,
+            "node_label": record.node_label,
+            "role_name": record.role_name,
+            "tab_id": record.tab_id,
+            "tab_title": record.tab_title,
+            "provider_id": record.provider_id,
+            "provider_name": record.provider_name,
+            "provider_type": record.provider_type,
+            "model": record.model,
+            "started_at": record.started_at,
+            "ended_at": record.ended_at,
+            "duration_ms": max(0.0, (record.ended_at - record.started_at) * 1000),
+            "retry_count": max(record.retry_count, 0),
+            "result": record.result,
+            "error_summary": record.error_summary,
+            "normalized_usage": serialize_usage(record.normalized_usage),
+            "raw_usage": copy.deepcopy(record.raw_usage),
+        }
+        with self._lock:
+            connection = open_state_db(create=True)
+            assert connection is not None
+            try:
+                with connection:
+                    self._prune_locked(connection, time.time())
+                    connection.execute(
+                        """
+                        INSERT INTO llm_request_records (id, ended_at, payload)
+                        VALUES (?, ?, ?)
+                        """,
+                        (
+                            payload["id"],
+                            payload["ended_at"],
+                            json.dumps(payload, ensure_ascii=False),
+                        ),
+                    )
+            finally:
+                connection.close()
+    def record_compact(self, record: CompactRecordInput) -> None:
+        payload = {
+            "id": str(uuid.uuid4()),
+            "node_id": record.node_id,
+            "node_label": record.node_label,
+            "role_name": record.role_name,
+            "tab_id": record.tab_id,
+            "tab_title": record.tab_title,
+            "provider_id": record.provider_id,
+            "provider_name": record.provider_name,
+            "provider_type": record.provider_type,
+            "model": record.model,
+            "trigger_type": record.trigger_type,
+            "started_at": record.started_at,
+            "ended_at": record.ended_at,
+            "duration_ms": max(0.0, (record.ended_at - record.started_at) * 1000),
+            "result": record.result,
+            "error_summary": record.error_summary,
+        }
+        with self._lock:
+            connection = open_state_db(create=True)
+            assert connection is not None
+            try:
+                with connection:
+                    self._prune_locked(connection, time.time())
+                    connection.execute(
+                        """
+                        INSERT INTO compact_records (id, ended_at, payload)
+                        VALUES (?, ?, ?)
+                        """,
+                        (
+                            payload["id"],
+                            payload["ended_at"],
+                            json.dumps(payload, ensure_ascii=False),
+                        ),
+                    )
+            finally:
+                connection.close()
+    def list_requests(self, *, since: float) -> list[dict[str, Any]]:
+        with self._lock:
+            return self._list_records(
+                table_name="llm_request_records",
+                since=since,
+            )
+    def list_compacts(self, *, since: float) -> list[dict[str, Any]]:
+        with self._lock:
+            return self._list_records(
+                table_name="compact_records",
+                since=since,
+            )
+    def _list_records(self, *, table_name: str, since: float) -> list[dict[str, Any]]:
+        connection = open_state_db(create=False)
+        if connection is None:
+            return []
+        try:
+            with connection:
+                self._prune_locked(connection, time.time())
+                rows = connection.execute(
+                    f"""
+                    SELECT payload
+                    FROM {table_name}
+                    WHERE ended_at >= ?
+                    ORDER BY ended_at
+                    """,
+                    (since,),
+                ).fetchall()
+        finally:
+            connection.close()
+        records: list[dict[str, Any]] = []
+        for row in rows:
+            payload = row["payload"]
+            if not isinstance(payload, str):
+                continue
+            parsed = json.loads(payload)
+            if isinstance(parsed, dict):
+                records.append(parsed)
+        return records
+stats_store = StatsStore()

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

@@ -0,0 +1,201 @@
+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",
+)
+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.settings import find_role, get_settings
+        from flowent.tools.mcp import DynamicMCPTool
+        allowed = set(agent.config.tools) | set(MINIMUM_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
+        ]
+        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() -> 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
+        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",
+            }
+        )
+    descriptors.extend(mcp_service.list_discovered_tool_descriptors())
+    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,156 @@
+from __future__ import annotations
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+from flowent.graph_runtime import resolve_node_ref
+from flowent.models import NodeType
+from flowent.tools import Tool
+from flowent.workspace_store import workspace_store
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+def _resolve_workflow_node_ref(
+    *,
+    tab_id: str,
+    node_ref: str,
+) -> tuple[str, str] | None:
+    target = resolve_node_ref(node_ref)
+    if target is not None and target.config.tab_id == tab_id:
+        return target.uuid, target.config.tab_id
+    tab = workspace_store.get_tab(tab_id)
+    if tab is None:
+        return None
+    definition_nodes = list(tab.definition.nodes)
+    exact_match = next(
+        (node for node in definition_nodes if node.id == node_ref),
+        None,
+    )
+    if exact_match is not None:
+        return exact_match.id, tab_id
+    named_matches = [
+        node
+        for node in definition_nodes
+        if isinstance(node.config.get("name"), str) and node.config["name"] == node_ref
+    ]
+    if len(named_matches) == 1:
+        return named_matches[0].id, tab_id
+    if 4 <= len(node_ref) < 36:
+        prefix_matches = [
+            node for node in definition_nodes if node.id.startswith(node_ref)
+        ]
+        if len(prefix_matches) == 1:
+            return prefix_matches[0].id, tab_id
+    return None
+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",
+            },
+            "kind": {
+                "type": "string",
+                "enum": ["control", "data", "event"],
+                "description": "Workflow edge kind",
+                "default": "control",
+            },
+        },
+        "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
+        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")
+        kind = args.get("kind", "control")
+        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 kind not in {"control", "data", "event"}:
+            return json.dumps({"error": "kind must be control, data, or event"})
+        if not agent.config.tab_id:
+            return json.dumps(
+                {"error": "Only a workflow Leader may connect task nodes"}
+            )
+        source = _resolve_workflow_node_ref(
+            tab_id=agent.config.tab_id,
+            node_ref=from_ref,
+        )
+        target = _resolve_workflow_node_ref(
+            tab_id=agent.config.tab_id,
+            node_ref=to_ref,
+        )
+        if source is None:
+            return json.dumps({"error": f"Node '{from_ref}' not found"})
+        if target is None:
+            return json.dumps({"error": f"Node '{to_ref}' not found"})
+        source_id, source_tab_id = source
+        target_id, target_tab_id = target
+        if source_tab_id != target_tab_id:
+            return json.dumps({"error": "Both nodes must belong to the same workflow"})
+        if agent.node_type == NodeType.ASSISTANT:
+            return json.dumps(
+                {"error": "Assistant may not rewire a Workflow Graph directly"}
+            )
+        if agent.config.tab_id != source_tab_id:
+            return json.dumps(
+                {
+                    "error": "A workflow Leader may only connect peers inside its own workflow"
+                }
+            )
+        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=source_tab_id,
+            from_node_id=source_id,
+            from_port_key=from_port_key,
+            to_node_id=target_id,
+            to_port_key=to_port_key,
+            kind=kind,
+        )
+        if error is not None or edge is None:
+            return json.dumps({"error": error or "Failed to connect nodes"})
+        return json.dumps(edge.serialize())