flowent 0.0.6 → 0.0.10

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

@@ -1,364 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, Any, ClassVar
-
-if TYPE_CHECKING:
-    from flowent.agent import Agent
-
-from flowent.settings_management import (
-    MISSING,
-    apply_resolved_settings_update,
-    resolve_settings_update,
-    serialize_manage_settings,
-)
-from flowent.tools import Tool
-
-
-class ManageSettingsTool(Tool):
-    name = "manage_settings"
-    description = (
-        "Read and update system settings, including the Assistant role, Leader "
-        "role, active provider and model, default model params, event log "
-        "timestamp format, and other runtime defaults."
-    )
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "action": {
-                "type": "string",
-                "enum": ["get", "update"],
-                "description": "Settings action",
-            },
-            "active_provider_id": {
-                "type": "string",
-                "description": "Active provider ID for update",
-            },
-            "assistant_role_name": {
-                "type": "string",
-                "description": "Role name used by the Assistant",
-            },
-            "assistant_allow_network": {
-                "type": "boolean",
-                "description": "Whether the Assistant may use networked tools or paths",
-            },
-            "assistant_write_dirs": {
-                "type": "array",
-                "description": "Writable directory boundaries for the Assistant",
-                "items": {"type": "string"},
-            },
-            "working_dir": {
-                "type": "string",
-                "description": "System working directory used as the default cwd and relative path base",
-            },
-            "leader_role_name": {
-                "type": "string",
-                "description": "Role name used by workflow Leaders",
-            },
-            "active_model": {
-                "type": "string",
-                "description": "Active model name for update",
-            },
-            "context_window_tokens": {
-                "type": ["integer", "null"],
-                "description": "Explicit context window override for the active system model",
-            },
-            "input_image": {
-                "type": ["boolean", "null"],
-                "description": "Explicit input_image override for the active system model",
-            },
-            "output_image": {
-                "type": ["boolean", "null"],
-                "description": "Explicit output_image override for the active system model",
-            },
-            "structured_output": {
-                "type": ["boolean", "null"],
-                "description": "Explicit structured_output override for the active system model",
-            },
-            "max_retries": {
-                "type": "integer",
-                "description": "Maximum retries for transient LLM call failures when retry_policy is limited",
-            },
-            "retry_initial_delay_seconds": {
-                "type": "number",
-                "description": "Initial exponential backoff delay in seconds",
-            },
-            "retry_max_delay_seconds": {
-                "type": "number",
-                "description": "Maximum exponential backoff delay in seconds",
-            },
-            "retry_backoff_cap_retries": {
-                "type": "integer",
-                "description": "Retry count where exponential growth stops doubling",
-            },
-            "auto_compact_token_limit": {
-                "type": ["integer", "null"],
-                "description": "Token-usage threshold where the runtime should auto compact before the next formal LLM call",
-            },
-            "retry_policy": {
-                "type": "string",
-                "enum": ["no_retry", "limited", "unlimited"],
-                "description": "System-wide retry policy for transient LLM call failures",
-            },
-            "timeout_ms": {
-                "type": "integer",
-                "description": "Single LLM request timeout in milliseconds",
-            },
-            "model_params": {
-                "type": ["object", "null"],
-                "description": "Default 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,
-            },
-            "timestamp_format": {
-                "type": "string",
-                "description": "Event log timestamp format for update",
-            },
-        },
-        "required": ["action"],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        from flowent.graph_service import sync_assistant_role, sync_tab_leaders
-        from flowent.providers.gateway import gateway
-        from flowent.settings import (
-            build_model_auto_compact_token_limit,
-            build_model_context_window_tokens,
-            build_model_input_image,
-            build_model_max_retries,
-            build_model_output_image,
-            build_model_retry_backoff_cap_retries,
-            build_model_retry_initial_delay_seconds,
-            build_model_retry_max_delay_seconds,
-            build_model_retry_policy,
-            build_model_structured_output,
-            build_model_timeout_ms,
-            get_settings,
-            save_settings,
-        )
-
-        action = args.get("action")
-        assistant_role_name = args.get("assistant_role_name")
-        assistant_allow_network = args.get("assistant_allow_network")
-        assistant_write_dirs = args.get("assistant_write_dirs")
-        working_dir = args.get("working_dir")
-        leader_role_name = args.get("leader_role_name")
-        active_provider_id = args.get("active_provider_id")
-        active_model = args.get("active_model")
-        timeout_ms = args.get("timeout_ms")
-        retry_policy = args.get("retry_policy")
-        max_retries = args.get("max_retries")
-        retry_initial_delay_seconds = args.get("retry_initial_delay_seconds")
-        retry_max_delay_seconds = args.get("retry_max_delay_seconds")
-        retry_backoff_cap_retries = args.get("retry_backoff_cap_retries")
-        context_window_tokens = args.get("context_window_tokens")
-        input_image = args.get("input_image")
-        output_image = args.get("output_image")
-        structured_output = args.get("structured_output")
-        auto_compact_token_limit = args.get("auto_compact_token_limit")
-        model_params = args.get("model_params")
-        timestamp_format = args.get("timestamp_format")
-
-        if not isinstance(action, str):
-            return json.dumps({"error": "action must be a string"})
-
-        if assistant_role_name is not None and not isinstance(assistant_role_name, str):
-            return json.dumps({"error": "assistant_role_name must be a string"})
-        if assistant_allow_network is not None and not isinstance(
-            assistant_allow_network, bool
-        ):
-            return json.dumps({"error": "assistant_allow_network must be a boolean"})
-        if assistant_write_dirs is not None and not isinstance(
-            assistant_write_dirs, list
-        ):
-            return json.dumps(
-                {"error": "assistant_write_dirs must be an array of strings"}
-            )
-        if working_dir is not None and not isinstance(working_dir, str):
-            return json.dumps({"error": "working_dir must be a string"})
-        if leader_role_name is not None and not isinstance(leader_role_name, str):
-            return json.dumps({"error": "leader_role_name must be a string"})
-        if active_provider_id is not None and not isinstance(active_provider_id, str):
-            return json.dumps({"error": "active_provider_id must be a string"})
-        if active_model is not None and not isinstance(active_model, str):
-            return json.dumps({"error": "active_model must be a string"})
-        if retry_policy is not None:
-            try:
-                build_model_retry_policy(retry_policy, field_name="retry_policy")
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if timeout_ms is not None:
-            try:
-                build_model_timeout_ms(timeout_ms, field_name="timeout_ms")
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if max_retries is not None:
-            try:
-                build_model_max_retries(max_retries, field_name="max_retries")
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if retry_initial_delay_seconds is not None:
-            try:
-                build_model_retry_initial_delay_seconds(
-                    retry_initial_delay_seconds,
-                    field_name="retry_initial_delay_seconds",
-                )
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if retry_max_delay_seconds is not None:
-            try:
-                build_model_retry_max_delay_seconds(
-                    retry_max_delay_seconds,
-                    field_name="retry_max_delay_seconds",
-                )
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if retry_backoff_cap_retries is not None:
-            try:
-                build_model_retry_backoff_cap_retries(
-                    retry_backoff_cap_retries,
-                    field_name="retry_backoff_cap_retries",
-                )
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if "input_image" in args:
-            try:
-                build_model_input_image(input_image, field_name="input_image")
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if "output_image" in args:
-            try:
-                build_model_output_image(output_image, field_name="output_image")
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if "structured_output" in args:
-            try:
-                build_model_structured_output(
-                    structured_output,
-                    field_name="structured_output",
-                )
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if "context_window_tokens" in args:
-            try:
-                build_model_context_window_tokens(
-                    context_window_tokens,
-                    field_name="context_window_tokens",
-                )
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if "auto_compact_token_limit" in args:
-            try:
-                build_model_auto_compact_token_limit(
-                    auto_compact_token_limit,
-                    field_name="auto_compact_token_limit",
-                )
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-        if model_params is not None and not isinstance(
-            model_params, (dict, type(None))
-        ):
-            return json.dumps({"error": "model_params must be an object or null"})
-        if timestamp_format is not None and not isinstance(timestamp_format, str):
-            return json.dumps({"error": "timestamp_format must be a string"})
-
-        settings = get_settings()
-
-        if action == "get":
-            return json.dumps(serialize_manage_settings(settings))
-
-        if action != "update":
-            return json.dumps({"error": f"Unsupported action: {action}"})
-
-        try:
-            resolved = resolve_settings_update(
-                settings,
-                working_dir=working_dir,
-                assistant_role_name=assistant_role_name,
-                assistant_allow_network=(
-                    assistant_allow_network
-                    if assistant_allow_network is not None
-                    else MISSING
-                ),
-                assistant_write_dirs=(
-                    assistant_write_dirs
-                    if assistant_write_dirs is not None
-                    else MISSING
-                ),
-                leader_role_name=leader_role_name,
-                active_provider_id=active_provider_id,
-                active_model=active_model,
-                context_window_tokens=(
-                    context_window_tokens
-                    if "context_window_tokens" in args
-                    else MISSING
-                ),
-                input_image=input_image if "input_image" in args else MISSING,
-                output_image=output_image if "output_image" in args else MISSING,
-                structured_output=(
-                    structured_output if "structured_output" in args else MISSING
-                ),
-                max_retries=max_retries if max_retries is not None else MISSING,
-                retry_policy=retry_policy if retry_policy is not None else MISSING,
-                timeout_ms=timeout_ms if timeout_ms is not None else MISSING,
-                retry_initial_delay_seconds=(
-                    retry_initial_delay_seconds
-                    if retry_initial_delay_seconds is not None
-                    else MISSING
-                ),
-                retry_max_delay_seconds=(
-                    retry_max_delay_seconds
-                    if retry_max_delay_seconds is not None
-                    else MISSING
-                ),
-                retry_backoff_cap_retries=(
-                    retry_backoff_cap_retries
-                    if retry_backoff_cap_retries is not None
-                    else MISSING
-                ),
-                auto_compact_token_limit=(
-                    auto_compact_token_limit
-                    if "auto_compact_token_limit" in args
-                    else MISSING
-                ),
-                model_params=model_params if "model_params" in args else MISSING,
-                timestamp_format=timestamp_format,
-                assistant_role_field_name="assistant_role_name",
-                assistant_allow_network_field_name="assistant_allow_network",
-                assistant_write_dirs_field_name="assistant_write_dirs",
-                leader_role_field_name="leader_role_name",
-                working_dir_field_name="working_dir",
-                retry_policy_field_name="retry_policy",
-                timeout_ms_field_name="timeout_ms",
-                max_retries_field_name="max_retries",
-                retry_initial_delay_seconds_field_name="retry_initial_delay_seconds",
-                retry_max_delay_seconds_field_name="retry_max_delay_seconds",
-                retry_backoff_cap_retries_field_name="retry_backoff_cap_retries",
-                input_image_field_name="input_image",
-                output_image_field_name="output_image",
-                structured_output_field_name="structured_output",
-                context_window_tokens_field_name="context_window_tokens",
-                auto_compact_token_limit_field_name="auto_compact_token_limit",
-            )
-        except ValueError as exc:
-            return json.dumps({"error": str(exc)})
-
-        apply_resolved_settings_update(settings, resolved)
-
-        save_settings(settings)
-        sync_assistant_role(reason="assistant settings updated")
-        sync_tab_leaders(reason="leader settings updated")
-        gateway.invalidate_cache()
-        return json.dumps(serialize_manage_settings(settings))

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

@@ -1,199 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, Any, ClassVar
-
-from flowent.mcp_service import MCPToolDescriptor, mcp_service
-from flowent.tools import Tool
-
-if TYPE_CHECKING:
-    from flowent.agent import Agent
-
-
-class DynamicMCPTool(Tool):
-    agent_visible = True
-    llm_visible = True
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {},
-        "required": [],
-    }
-
-    def __init__(self, descriptor: MCPToolDescriptor) -> None:
-        self._descriptor = descriptor
-        self.name = descriptor.fully_qualified_id
-        self.description = descriptor.description or f"MCP tool {descriptor.tool_name}"
-        self._parameters = descriptor.input_schema or {
-            "type": "object",
-            "properties": {},
-            "required": [],
-        }
-
-    def to_schema(self) -> dict[str, Any]:
-        return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": self._parameters,
-            },
-        }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        result = mcp_service.call_agent_tool(
-            agent,
-            fully_qualified_id=self._descriptor.fully_qualified_id,
-            arguments=args,
-        )
-        return json.dumps(result, ensure_ascii=False)
-
-
-class ListMCPResourcesTool(Tool):
-    name = "list_mcp_resources"
-    description = "List MCP resources visible in the current execution boundary."
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "server_name": {
-                "type": "string",
-                "description": "Optional globally available MCP server name filter",
-            }
-        },
-        "required": [],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        server_name = args.get("server_name")
-        resources = mcp_service.list_agent_resources(
-            agent,
-            server_name=server_name
-            if isinstance(server_name, str) and server_name.strip()
-            else None,
-        )
-        return json.dumps(resources, ensure_ascii=False)
-
-
-class ListMCPResourceTemplatesTool(Tool):
-    name = "list_mcp_resource_templates"
-    description = (
-        "List MCP resource templates visible in the current execution boundary."
-    )
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "server_name": {
-                "type": "string",
-                "description": "Optional globally available MCP server name filter",
-            }
-        },
-        "required": [],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        server_name = args.get("server_name")
-        templates = mcp_service.list_agent_resource_templates(
-            agent,
-            server_name=server_name
-            if isinstance(server_name, str) and server_name.strip()
-            else None,
-        )
-        return json.dumps(templates, ensure_ascii=False)
-
-
-class ReadMCPResourceTool(Tool):
-    name = "read_mcp_resource"
-    description = "Read an MCP resource from a globally available server."
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "server_name": {
-                "type": "string",
-                "description": "Globally available MCP server name",
-            },
-            "uri": {
-                "type": "string",
-                "description": "Target MCP resource URI",
-            },
-        },
-        "required": ["server_name", "uri"],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        server_name = args.get("server_name")
-        uri = args.get("uri")
-        if not isinstance(server_name, str) or not server_name.strip():
-            return json.dumps({"error": "server_name is required"})
-        if not isinstance(uri, str) or not uri.strip():
-            return json.dumps({"error": "uri is required"})
-        result = mcp_service.read_agent_resource(
-            agent,
-            server_name=server_name.strip(),
-            uri=uri.strip(),
-        )
-        return json.dumps(result, ensure_ascii=False)
-
-
-class ListMCPPromptsTool(Tool):
-    name = "list_mcp_prompts"
-    description = "List MCP prompts visible in the current execution boundary."
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "server_name": {
-                "type": "string",
-                "description": "Optional globally available MCP server name filter",
-            }
-        },
-        "required": [],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        server_name = args.get("server_name")
-        prompts = mcp_service.list_agent_prompts(
-            agent,
-            server_name=server_name
-            if isinstance(server_name, str) and server_name.strip()
-            else None,
-        )
-        return json.dumps(prompts, ensure_ascii=False)
-
-
-class GetMCPPromptTool(Tool):
-    name = "get_mcp_prompt"
-    description = "Get an MCP prompt from a globally available server."
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "server_name": {
-                "type": "string",
-                "description": "Globally available MCP server name",
-            },
-            "name": {
-                "type": "string",
-                "description": "Prompt name",
-            },
-            "arguments": {
-                "type": "object",
-                "description": "Optional prompt arguments",
-            },
-        },
-        "required": ["server_name", "name"],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        server_name = args.get("server_name")
-        name = args.get("name")
-        arguments = args.get("arguments")
-        if not isinstance(server_name, str) or not server_name.strip():
-            return json.dumps({"error": "server_name is required"})
-        if not isinstance(name, str) or not name.strip():
-            return json.dumps({"error": "name is required"})
-        if arguments is not None and not isinstance(arguments, dict):
-            return json.dumps({"error": "arguments must be an object"})
-        result = mcp_service.get_agent_prompt(
-            agent,
-            server_name=server_name.strip(),
-            name=name.strip(),
-            arguments=arguments if isinstance(arguments, dict) else None,
-        )
-        return json.dumps(result, ensure_ascii=False)