flowent 0.0.0 → 0.0.4

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

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from loguru import logger
+
+from flowent.network import create_http_session, iter_response_text
+from flowent.tools import Tool, re_raise_interrupt
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class FetchTool(Tool):
+    name = "fetch"
+    description = "Make an HTTP request."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "method": {
+                "type": "string",
+                "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"],
+                "description": "HTTP method",
+            },
+            "url": {"type": "string", "description": "Request URL"},
+            "headers": {
+                "type": "object",
+                "description": "Request headers (optional)",
+            },
+            "body": {"type": "string", "description": "Request body (optional)"},
+        },
+        "required": ["method", "url"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **kwargs: Any) -> str:
+        method = args["method"]
+        url = args["url"]
+        on_output: Callable[[str], None] | None = kwargs.get("on_output")
+        logger.debug("HTTP {} {}", method, url)
+        try:
+            with (
+                create_http_session(timeout=30.0, impersonate_browser=True) as client,
+                client.stream(
+                    method,
+                    url,
+                    headers=args.get("headers"),
+                    data=args.get("body"),
+                ) as response,
+            ):
+                close_response = getattr(response, "close", None)
+                agent.set_interrupt_callback(
+                    close_response if callable(close_response) else None
+                )
+                if on_output is not None:
+                    on_output(f"{method} {url}\n")
+                    on_output(f"HTTP {response.status_code}\n\n")
+
+                remaining = 5000
+                body_parts: list[str] = []
+                for chunk in iter_response_text(response):
+                    if not chunk or remaining <= 0:
+                        continue
+                    if len(chunk) > remaining:
+                        chunk = chunk[:remaining]
+                    body_parts.append(chunk)
+                    remaining -= len(chunk)
+                    if on_output is not None:
+                        on_output(chunk)
+
+            body = "".join(body_parts)
+            logger.debug("HTTP {} {} -> {}", method, url, response.status_code)
+            return json.dumps(
+                {
+                    "status_code": response.status_code,
+                    "body": body,
+                }
+            )
+        except Exception as e:
+            re_raise_interrupt(agent, e)
+            logger.warning("HTTP request failed: {} {} - {}", method, url, e)
+            return json.dumps({"error": str(e)})
+        finally:
+            agent.set_interrupt_callback(None)

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

@@ -0,0 +1,27 @@
+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 IdleTool(Tool):
+    name = "idle"
+    description = (
+        "Enter idle state. The agent suspends execution until a wake signal re-activates it. "
+        "Use this when the current step or task is finished, paused, or blocked, and there is no "
+        "immediate next action to take right now. Incoming messages will automatically re-activate you as new input messages, and the tool returns the idle duration when execution resumes."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {},
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **kwargs: Any) -> str:
+        tool_call_id = kwargs.get("tool_call_id")
+        if tool_call_id is not None and not isinstance(tool_call_id, str):
+            tool_call_id = None
+        return agent.request_idle(tool_call_id=tool_call_id)

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

@@ -0,0 +1,50 @@
+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 ListRolesTool(Tool):
+    name = "list_roles"
+    description = "List all registered roles with builtin and optional tool views."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        from flowent.settings import get_settings, normalize_tool_names
+        from flowent.tools import MINIMUM_TOOLS, build_tool_registry
+
+        settings = get_settings()
+        tool_registry = build_tool_registry()
+        all_tool_names = [
+            tool.name for tool in tool_registry.list_tools(agent_visible_only=True)
+        ]
+        payload: list[dict[str, object]] = []
+
+        for role in settings.roles:
+            builtin_tools = normalize_tool_names([*MINIMUM_TOOLS, *role.included_tools])
+            optional_tools = [
+                tool_name
+                for tool_name in all_tool_names
+                if tool_name not in builtin_tools
+                and tool_name not in role.excluded_tools
+            ]
+            payload.append(
+                {
+                    "name": role.name,
+                    "description": role.description,
+                    "system_prompt": role.system_prompt,
+                    "builtin_tools": builtin_tools,
+                    "optional_tools": optional_tools,
+                }
+            )
+
+        return json.dumps(payload)

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

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from flowent.graph_service import (
+    is_tab_leader,
+    list_tab_edges,
+    list_tab_nodes,
+    list_workflow_nodes,
+    serialize_tab_summary,
+)
+from flowent.tools import Tool
+from flowent.workspace_store import workspace_store
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+
+class ListTabsTool(Tool):
+    name = "list_workflows"
+    description = "List persistent workflows. Optionally include the full Workflow Graph for one workflow."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "workflow_id": {
+                "type": "string",
+                "description": "Optional workflow ID to inspect in detail",
+            }
+        },
+        "required": [],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        workflow_id = args.get("workflow_id")
+        if workflow_id is not None and not isinstance(workflow_id, str):
+            return json.dumps({"error": "workflow_id must be a string"})
+
+        if isinstance(workflow_id, str) and workflow_id.strip():
+            tab = workspace_store.get_tab(workflow_id.strip())
+            if tab is None:
+                return json.dumps(
+                    {"error": f"Workflow '{workflow_id.strip()}' not found"}
+                )
+            nodes = [
+                {
+                    "id": node.id,
+                    "node_type": node.type.value,
+                    "name": (
+                        node.config["name"]
+                        if isinstance(node.config.get("name"), str)
+                        else None
+                    ),
+                    "role_name": (
+                        node.config["role_name"]
+                        if isinstance(node.config.get("role_name"), str)
+                        else None
+                    ),
+                    "is_leader": False,
+                    "position": (
+                        tab.definition.view.positions[node.id].serialize()
+                        if node.id in tab.definition.view.positions
+                        else None
+                    ),
+                }
+                for node in list_workflow_nodes(tab.id)
+            ]
+            return json.dumps(
+                {
+                    "workflow": serialize_tab_summary(tab),
+                    "nodes": nodes,
+                    "runtime_nodes": [
+                        {
+                            "id": node.id,
+                            "name": node.config.name,
+                            "role_name": node.config.role_name,
+                            "is_leader": is_tab_leader(
+                                node_id=node.id,
+                                tab_id=tab.id,
+                            ),
+                            "state": node.state.value,
+                            "position": (
+                                node.position.serialize()
+                                if node.position is not None
+                                else None
+                            ),
+                        }
+                        for node in list_tab_nodes(tab.id)
+                    ],
+                    "edges": [edge.serialize() for edge in list_tab_edges(tab.id)],
+                }
+            )
+
+        return json.dumps(
+            [serialize_tab_summary(tab) for tab in workspace_store.list_tabs()]
+        )

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

@@ -0,0 +1,24 @@
+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 ListToolsTool(Tool):
+    name = "list_tools"
+    description = "List all registered tools with their names and descriptions."
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        from flowent.tools import list_agent_visible_tool_descriptors
+
+        return json.dumps(list_agent_visible_tool_descriptors())

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

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+from flowent.tools import Tool
+
+
+class ManagePromptsTool(Tool):
+    name = "manage_prompts"
+    description = (
+        "Read and update the global custom prompt and custom post prompt. The "
+        "custom prompt is appended to every node's system prompt, and the "
+        "custom post prompt is appended after the built-in runtime post prompt "
+        "in every runtime request tail."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["get", "update"],
+                "description": "Prompt management action",
+            },
+            "custom_prompt": {
+                "type": "string",
+                "description": "Updated global custom prompt",
+            },
+            "custom_post_prompt": {
+                "type": "string",
+                "description": "Updated global custom post prompt",
+            },
+        },
+        "required": ["action"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
+        from flowent.settings import get_settings, save_settings
+
+        action = args.get("action")
+        custom_prompt = args.get("custom_prompt")
+        custom_post_prompt = args.get("custom_post_prompt")
+        legacy_post_prompt = args.get("post_prompt")
+
+        if not isinstance(action, str):
+            return json.dumps({"error": "action must be a string"})
+
+        settings = get_settings()
+
+        if action == "get":
+            return json.dumps(
+                {
+                    "custom_prompt": settings.custom_prompt,
+                    "custom_post_prompt": settings.custom_post_prompt,
+                }
+            )
+
+        if action != "update":
+            return json.dumps({"error": f"Unsupported action: {action}"})
+
+        if (
+            "custom_prompt" not in args
+            and "custom_post_prompt" not in args
+            and "post_prompt" not in args
+        ):
+            return json.dumps(
+                {"error": "custom_prompt or custom_post_prompt is required"}
+            )
+        if "custom_prompt" in args and not isinstance(custom_prompt, str):
+            return json.dumps({"error": "custom_prompt must be a string"})
+        if "custom_post_prompt" in args and not isinstance(custom_post_prompt, str):
+            return json.dumps({"error": "custom_post_prompt must be a string"})
+        if (
+            "post_prompt" in args
+            and "custom_post_prompt" not in args
+            and not isinstance(legacy_post_prompt, str)
+        ):
+            return json.dumps({"error": "custom_post_prompt must be a string"})
+
+        next_custom_prompt = custom_prompt if isinstance(custom_prompt, str) else None
+        next_custom_post_prompt = (
+            custom_post_prompt
+            if isinstance(custom_post_prompt, str)
+            else legacy_post_prompt
+            if isinstance(legacy_post_prompt, str)
+            else None
+        )
+
+        if next_custom_prompt is not None:
+            settings.custom_prompt = next_custom_prompt
+        if next_custom_post_prompt is not None:
+            settings.custom_post_prompt = next_custom_post_prompt
+        save_settings(settings)
+        return json.dumps(
+            {
+                "custom_prompt": settings.custom_prompt,
+                "custom_post_prompt": settings.custom_post_prompt,
+            }
+        )

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

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+from flowent.providers.configuration import serialize_discovered_model_catalog_entry
+from flowent.providers.management import (
+    ProviderNotFoundError,
+    create_provider_entry,
+    delete_provider_entry,
+    list_provider_payloads,
+    update_provider_entry,
+)
+from flowent.settings import (
+    build_provider_headers,
+    build_provider_retry_429_delay_seconds,
+)
+from flowent.tools import Tool, re_raise_interrupt
+
+
+class ManageProvidersTool(Tool):
+    name = "manage_providers"
+    description = (
+        "Manage LLM provider configuration. Supports listing, creating, "
+        "updating, deleting providers, and listing models for a provider."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["list", "create", "update", "delete", "list_models"],
+                "description": "Provider management action",
+            },
+            "id": {
+                "type": "string",
+                "description": "Target provider ID for update, delete, or list_models",
+            },
+            "name": {
+                "type": "string",
+                "description": "Provider display name",
+            },
+            "type": {
+                "type": "string",
+                "description": "Provider type, such as openai_compatible",
+            },
+            "base_url": {
+                "type": "string",
+                "description": "Provider API base URL",
+            },
+            "api_key": {
+                "type": "string",
+                "description": "Provider API key",
+            },
+            "headers": {
+                "type": "object",
+                "description": "Provider request header overrides",
+                "additionalProperties": {"type": "string"},
+            },
+            "retry_429_delay_seconds": {
+                "type": "integer",
+                "description": "Extra wait time in seconds after HTTP 429 before retrying",
+            },
+        },
+        "required": ["action"],
+    }
+
+    def execute(self, agent: Agent, args: dict[str, Any], **kwargs: Any) -> str:
+        from flowent.providers.gateway import gateway
+        from flowent.settings import get_settings, save_settings
+
+        on_output: Callable[[str], None] | None = kwargs.get("on_output")
+        action = args.get("action")
+        provider_id = args.get("id")
+        name = args.get("name")
+        provider_type = args.get("type")
+        base_url = args.get("base_url")
+        api_key = args.get("api_key")
+        raw_headers = args.get("headers")
+        retry_429_delay_seconds = args.get("retry_429_delay_seconds")
+
+        if not isinstance(action, str):
+            return json.dumps({"error": "action must be a string"})
+
+        if provider_id is not None and not isinstance(provider_id, str):
+            return json.dumps({"error": "id must be a string"})
+        if name is not None and not isinstance(name, str):
+            return json.dumps({"error": "name must be a string"})
+        if provider_type is not None and not isinstance(provider_type, str):
+            return json.dumps({"error": "type must be a string"})
+        if base_url is not None and not isinstance(base_url, str):
+            return json.dumps({"error": "base_url must be a string"})
+        if api_key is not None and not isinstance(api_key, str):
+            return json.dumps({"error": "api_key must be a string"})
+        if raw_headers is not None and not isinstance(raw_headers, dict):
+            return json.dumps({"error": "headers must be a JSON object"})
+        if retry_429_delay_seconds is not None:
+            try:
+                build_provider_retry_429_delay_seconds(retry_429_delay_seconds)
+            except ValueError as exc:
+                return json.dumps({"error": str(exc)})
+
+        try:
+            headers = (
+                build_provider_headers(raw_headers) if raw_headers is not None else None
+            )
+        except ValueError as exc:
+            return json.dumps({"error": str(exc)})
+
+        settings = get_settings()
+
+        if action == "list":
+            return json.dumps(list_provider_payloads(settings, include_api_key=False))
+
+        if action == "create":
+            if not isinstance(name, str) or not name.strip():
+                return json.dumps({"error": "name is required"})
+            if not isinstance(provider_type, str) or not provider_type.strip():
+                return json.dumps({"error": "type is required"})
+            if not isinstance(base_url, str) or not base_url.strip():
+                return json.dumps({"error": "base_url is required"})
+            try:
+                provider = create_provider_entry(
+                    settings,
+                    name=name,
+                    provider_type=provider_type,
+                    base_url=base_url,
+                    api_key=api_key or "",
+                    raw_headers=headers,
+                    raw_retry_429_delay_seconds=(
+                        retry_429_delay_seconds
+                        if retry_429_delay_seconds is not None
+                        else 0
+                    ),
+                    base_url_required_message="base_url is required",
+                )
+            except ValueError as exc:
+                return json.dumps({"error": str(exc)})
+            save_settings(settings)
+            gateway.invalidate_cache()
+            return json.dumps(
+                list_provider_payloads(settings, include_api_key=False)[-1]
+            )
+
+        if action == "update":
+            if not isinstance(provider_id, str) or not provider_id:
+                return json.dumps({"error": "id is required"})
+
+            try:
+                provider = update_provider_entry(
+                    settings,
+                    provider_id,
+                    name=name,
+                    provider_type=provider_type,
+                    base_url=base_url,
+                    api_key=api_key,
+                    raw_headers=headers,
+                    raw_retry_429_delay_seconds=retry_429_delay_seconds,
+                )
+            except ValueError as exc:
+                return json.dumps({"error": str(exc)})
+            except ProviderNotFoundError:
+                return json.dumps({"error": f"Provider '{provider_id}' not found"})
+            save_settings(settings)
+            gateway.invalidate_cache()
+            return json.dumps(
+                list_provider_payloads(settings, include_api_key=False)[
+                    settings.providers.index(provider)
+                ]
+            )
+
+        if action == "delete":
+            if not isinstance(provider_id, str) or not provider_id:
+                return json.dumps({"error": "id is required"})
+
+            try:
+                delete_provider_entry(settings, provider_id)
+            except ProviderNotFoundError:
+                return json.dumps({"error": f"Provider '{provider_id}' not found"})
+            save_settings(settings)
+            gateway.invalidate_cache()
+            return json.dumps({"status": "deleted"})
+
+        if action == "list_models":
+            if not isinstance(provider_id, str) or not provider_id:
+                return json.dumps({"error": "id is required"})
+            try:
+                if on_output is not None:
+                    on_output(f"Listing models for {provider_id}\n")
+                models = gateway.list_models_for(
+                    provider_id,
+                    register_interrupt=agent.set_interrupt_callback,
+                )
+                if on_output is not None:
+                    for model in models:
+                        on_output(f"{model.id}\n")
+                return json.dumps(
+                    [
+                        serialize_discovered_model_catalog_entry(model)
+                        for model in models
+                    ]
+                )
+            except Exception as exc:
+                re_raise_interrupt(agent, exc)
+                logger.error(
+                    "Failed to list models for provider '{}': {}",
+                    provider_id,
+                    exc,
+                )
+                return json.dumps({"error": str(exc)})
+            finally:
+                agent.set_interrupt_callback(None)
+
+        return json.dumps({"error": f"Unsupported action: {action}"})