flowent 0.0.1 → 0.0.5

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}"})

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

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, ClassVar
+
+if TYPE_CHECKING:
+    from flowent.agent import Agent
+
+from flowent.role_management import (
+    apply_role_update,
+    build_role_config,
+    ensure_role_name_available,
+    find_role_by_name,
+    normalize_optional_role_description,
+    normalize_optional_role_name,
+    remove_role,
+    require_role_description,
+    require_role_name,
+    resolve_role_model,
+    resolve_role_model_params,
+    resolve_role_tool_config,
+    sync_running_system_roles,
+    validate_builtin_role_update,
+)
+from flowent.tools import Tool
+
+
+class ManageRolesTool(Tool):
+    name = "manage_roles"
+    description = (
+        "Manage Role configuration. Supports listing, creating, updating, "
+        "and deleting roles. Built-in roles cannot be deleted, renamed, "
+        "or modified except for model and model_params configuration."
+    )
+    parameters: ClassVar[dict[str, Any]] = {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["list", "create", "update", "delete"],
+                "description": "Role management action",
+            },
+            "name": {
+                "type": "string",
+                "description": "Role name for create, update, or delete",
+            },
+            "new_name": {
+                "type": "string",
+                "description": "New role name for update",
+            },
+            "description": {
+                "type": "string",
+                "description": "Short role description used when choosing a role",
+            },
+            "system_prompt": {
+                "type": "string",
+                "description": "Role system prompt",
+            },
+            "model": {
+                "type": ["object", "null"],
+                "description": "Optional provider and model override for this role",
+                "properties": {
+                    "provider_id": {"type": "string"},
+                    "model": {"type": "string"},
+                },
+                "required": ["provider_id", "model"],
+                "additionalProperties": False,
+            },
+            "model_params": {
+                "type": ["object", "null"],
+                "description": "Optional canonical model parameter overrides",
+                "properties": {
+                    "reasoning_effort": {
+                        "type": "string",
+                        "enum": ["none", "low", "medium", "high", "xhigh"],
+                    },
+                    "verbosity": {
+                        "type": "string",
+                        "enum": ["low", "medium", "high"],
+                    },
+                    "max_output_tokens": {"type": "integer"},
+                    "temperature": {"type": "number"},
+                    "top_p": {"type": "number"},
+                },
+                "additionalProperties": False,
+            },
+            "included_tools": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Tools always included in the role",
+            },
+            "excluded_tools": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Tools always excluded from the role",
+            },
+        },
+        "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,
+            is_builtin_role_name,
+            save_settings,
+            serialize_role,
+        )
+
+        action = args.get("action")
+        role_name = args.get("name")
+        new_name = args.get("new_name")
+        description = args.get("description")
+        system_prompt = args.get("system_prompt")
+        role_model = args.get("model")
+        role_model_params = args.get("model_params")
+        included_tools = args.get("included_tools")
+        excluded_tools = args.get("excluded_tools")
+
+        if not isinstance(action, str):
+            return json.dumps({"error": "action must be a string"})
+
+        if role_name is not None and not isinstance(role_name, str):
+            return json.dumps({"error": "name must be a string"})
+        if new_name is not None and not isinstance(new_name, str):
+            return json.dumps({"error": "new_name must be a string"})
+        if description is not None and not isinstance(description, str):
+            return json.dumps({"error": "description must be a string"})
+        if system_prompt is not None and not isinstance(system_prompt, str):
+            return json.dumps({"error": "system_prompt must be a string"})
+        if included_tools is not None and (
+            not isinstance(included_tools, list)
+            or not all(isinstance(tool_name, str) for tool_name in included_tools)
+        ):
+            return json.dumps({"error": "included_tools must be an array of strings"})
+        if excluded_tools is not None and (
+            not isinstance(excluded_tools, list)
+            or not all(isinstance(tool_name, str) for tool_name in excluded_tools)
+        ):
+            return json.dumps({"error": "excluded_tools must be an array of strings"})
+
+        settings = get_settings()
+
+        if action == "list":
+            return json.dumps([serialize_role(role) for role in settings.roles])
+
+        if action == "create":
+            if not isinstance(system_prompt, str):
+                return json.dumps({"error": "system_prompt is required"})
+            try:
+                name = require_role_name(role_name or "")
+                description_text = require_role_description(description or "")
+                ensure_role_name_available(settings.roles, name)
+                next_included, next_excluded = resolve_role_tool_config(
+                    None,
+                    included_tools,
+                    excluded_tools,
+                )
+                next_model = resolve_role_model(
+                    role_model,
+                    settings=settings,
+                    current=None,
+                    provided="model" in args,
+                    invalid_type_error="model must be an object or null",
+                    missing_provider_id_error=(
+                        "model.provider_id must be a non-empty string"
+                    ),
+                    missing_model_error="model.model must be a non-empty string",
+                )
+                next_model_params = resolve_role_model_params(
+                    role_model_params,
+                    current=None,
+                    provided="model_params" in args,
+                )
+            except ValueError as exc:
+                return json.dumps({"error": str(exc)})
+            new_role = build_role_config(
+                name=name,
+                description=description_text,
+                system_prompt=system_prompt,
+                model=next_model,
+                model_params=next_model_params,
+                included_tools=next_included,
+                excluded_tools=next_excluded,
+            )
+            settings.roles.append(new_role)
+            save_settings(settings)
+            gateway.invalidate_cache()
+            return json.dumps(serialize_role(new_role))
+
+        if action == "update":
+            if not isinstance(role_name, str) or not role_name:
+                return json.dumps({"error": "name is required"})
+
+            target_role = find_role_by_name(settings.roles, role_name)
+            if target_role is None:
+                return json.dumps({"error": f"Role '{role_name}' not found"})
+
+            try:
+                next_included, next_excluded = resolve_role_tool_config(
+                    target_role,
+                    included_tools,
+                    excluded_tools,
+                )
+                next_model = resolve_role_model(
+                    role_model,
+                    settings=settings,
+                    current=target_role.model,
+                    provided="model" in args,
+                    invalid_type_error="model must be an object or null",
+                    missing_provider_id_error=(
+                        "model.provider_id must be a non-empty string"
+                    ),
+                    missing_model_error="model.model must be a non-empty string",
+                )
+                next_model_params = resolve_role_model_params(
+                    role_model_params,
+                    current=target_role.model_params,
+                    provided="model_params" in args,
+                )
+                stripped_name = normalize_optional_role_name(new_name)
+                stripped_description = normalize_optional_role_description(description)
+                if stripped_name is not None:
+                    ensure_role_name_available(
+                        settings.roles,
+                        stripped_name,
+                        current_name=target_role.name,
+                    )
+                validate_builtin_role_update(
+                    target_role,
+                    next_name=stripped_name,
+                    next_description=stripped_description,
+                    next_system_prompt=system_prompt,
+                    next_included_tools=next_included,
+                    next_excluded_tools=next_excluded,
+                )
+            except ValueError as exc:
+                return json.dumps({"error": str(exc)})
+            target_role = apply_role_update(
+                settings=settings,
+                role=target_role,
+                next_name=stripped_name,
+                next_description=stripped_description,
+                next_system_prompt=system_prompt,
+                next_model=next_model,
+                update_model="model" in args,
+                next_model_params=next_model_params,
+                update_model_params="model_params" in args,
+                next_included_tools=next_included,
+                next_excluded_tools=next_excluded,
+            )
+            save_settings(settings)
+            sync_running_system_roles()
+            gateway.invalidate_cache()
+            return json.dumps(serialize_role(target_role))
+
+        if action == "delete":
+            if not isinstance(role_name, str) or not role_name:
+                return json.dumps({"error": "name is required"})
+            if is_builtin_role_name(role_name):
+                return json.dumps(
+                    {"error": f"Cannot delete built-in role '{role_name}'"}
+                )
+
+            target_role = find_role_by_name(settings.roles, role_name)
+            if target_role is None:
+                return json.dumps({"error": f"Role '{role_name}' not found"})
+
+            remove_role(settings, target_role)
+            save_settings(settings)
+            sync_running_system_roles()
+            gateway.invalidate_cache()
+            return json.dumps({"status": "deleted"})
+
+        return json.dumps({"error": f"Unsupported action: {action}"})