flowent 0.0.7 → 0.0.10

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

@@ -1,326 +0,0 @@
-from __future__ import annotations
-
-import json
-from collections.abc import Callable
-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
-
-
-def _error(message: str) -> str:
-    return json.dumps({"error": message})
-
-
-def _validate_optional_string(value: object, field_name: str) -> str | None:
-    if value is not None and not isinstance(value, str):
-        return f"{field_name} must be a string"
-    return None
-
-
-def _validate_manage_settings_args(args: dict[str, Any]) -> str | None:
-    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,
-    )
-
-    action = args.get("action")
-    if not isinstance(action, str):
-        return "action must be a string"
-
-    for field_name in (
-        "assistant_role_name",
-        "working_dir",
-        "leader_role_name",
-        "active_provider_id",
-        "active_model",
-        "timestamp_format",
-    ):
-        error = _validate_optional_string(args.get(field_name), field_name)
-        if error is not None:
-            return error
-
-    assistant_allow_network = args.get("assistant_allow_network")
-    if assistant_allow_network is not None and not isinstance(
-        assistant_allow_network, bool
-    ):
-        return "assistant_allow_network must be a boolean"
-
-    assistant_write_dirs = args.get("assistant_write_dirs")
-    if assistant_write_dirs is not None and not isinstance(assistant_write_dirs, list):
-        return "assistant_write_dirs must be an array of strings"
-
-    builders: tuple[tuple[str, Callable[..., object]], ...] = (
-        ("retry_policy", build_model_retry_policy),
-        ("timeout_ms", build_model_timeout_ms),
-        ("max_retries", build_model_max_retries),
-        ("retry_initial_delay_seconds", build_model_retry_initial_delay_seconds),
-        ("retry_max_delay_seconds", build_model_retry_max_delay_seconds),
-        ("retry_backoff_cap_retries", build_model_retry_backoff_cap_retries),
-    )
-    for field_name, builder in builders:
-        if args.get(field_name) is None:
-            continue
-        try:
-            builder(args.get(field_name), field_name=field_name)
-        except ValueError as exc:
-            return str(exc)
-
-    optional_builders: tuple[tuple[str, Callable[..., object]], ...] = (
-        ("input_image", build_model_input_image),
-        ("output_image", build_model_output_image),
-        ("structured_output", build_model_structured_output),
-        ("context_window_tokens", build_model_context_window_tokens),
-        ("auto_compact_token_limit", build_model_auto_compact_token_limit),
-    )
-    for field_name, builder in optional_builders:
-        if field_name not in args:
-            continue
-        try:
-            builder(args.get(field_name), field_name=field_name)
-        except ValueError as exc:
-            return str(exc)
-
-    model_params = args.get("model_params")
-    if model_params is not None and not isinstance(model_params, (dict, type(None))):
-        return "model_params must be an object or null"
-
-    return None
-
-
-def _provided(args: dict[str, Any], field_name: str) -> object:
-    return args.get(field_name, MISSING)
-
-
-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 get_settings, save_settings
-
-        action = args.get("action")
-        validation_error = _validate_manage_settings_args(args)
-        if validation_error is not None:
-            return _error(validation_error)
-
-        settings = get_settings()
-
-        if action == "get":
-            return json.dumps(serialize_manage_settings(settings))
-
-        if action != "update":
-            return _error(f"Unsupported action: {action}")
-
-        try:
-            resolved = resolve_settings_update(
-                settings,
-                working_dir=args.get("working_dir"),
-                assistant_role_name=args.get("assistant_role_name"),
-                assistant_allow_network=(
-                    args.get("assistant_allow_network")
-                    if args.get("assistant_allow_network") is not None
-                    else MISSING
-                ),
-                assistant_write_dirs=(
-                    args.get("assistant_write_dirs")
-                    if args.get("assistant_write_dirs") is not None
-                    else MISSING
-                ),
-                leader_role_name=args.get("leader_role_name"),
-                active_provider_id=args.get("active_provider_id"),
-                active_model=args.get("active_model"),
-                context_window_tokens=_provided(args, "context_window_tokens"),
-                input_image=_provided(args, "input_image"),
-                output_image=_provided(args, "output_image"),
-                structured_output=_provided(args, "structured_output"),
-                max_retries=(
-                    args.get("max_retries")
-                    if args.get("max_retries") is not None
-                    else MISSING
-                ),
-                retry_policy=(
-                    args.get("retry_policy")
-                    if args.get("retry_policy") is not None
-                    else MISSING
-                ),
-                timeout_ms=(
-                    args.get("timeout_ms")
-                    if args.get("timeout_ms") is not None
-                    else MISSING
-                ),
-                retry_initial_delay_seconds=(
-                    args.get("retry_initial_delay_seconds")
-                    if args.get("retry_initial_delay_seconds") is not None
-                    else MISSING
-                ),
-                retry_max_delay_seconds=(
-                    args.get("retry_max_delay_seconds")
-                    if args.get("retry_max_delay_seconds") is not None
-                    else MISSING
-                ),
-                retry_backoff_cap_retries=(
-                    args.get("retry_backoff_cap_retries")
-                    if args.get("retry_backoff_cap_retries") is not None
-                    else MISSING
-                ),
-                auto_compact_token_limit=_provided(args, "auto_compact_token_limit"),
-                model_params=_provided(args, "model_params"),
-                timestamp_format=args.get("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 _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/read.py

@@ -1,152 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from collections.abc import Callable
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar
-
-from loguru import logger
-
-from flowent.tools import Tool, re_raise_interrupt
-
-if TYPE_CHECKING:
-    from flowent.agent import Agent
-
-
-def _append_stream_chunk(
-    buffer: list[str],
-    size: int,
-    text: str,
-    on_output: Callable[[str], None] | None,
-) -> int:
-    if on_output is None or not text:
-        return size
-    buffer.append(text)
-    size += len(text)
-    if size >= 2048:
-        on_output("".join(buffer))
-        buffer.clear()
-        return 0
-    return size
-
-
-def _flush_stream_chunk(
-    buffer: list[str], on_output: Callable[[str], None] | None
-) -> None:
-    if on_output is None or not buffer:
-        return
-    on_output("".join(buffer))
-    buffer.clear()
-
-
-class ReadTool(Tool):
-    name = "read"
-    description = (
-        "Read a file with line numbers, or list a directory. "
-        "Use start_line and end_line to read a specific range (1-indexed, inclusive). "
-        "Line numbers in the output are used as input to the edit tool."
-    )
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "path": {
-                "type": "string",
-                "description": "Absolute path to the file or directory to read",
-            },
-            "start_line": {
-                "type": "integer",
-                "description": "First line to read (1-indexed, inclusive). Defaults to 1.",
-            },
-            "end_line": {
-                "type": "integer",
-                "description": "Last line to read (1-indexed, inclusive). Defaults to end of file.",
-            },
-        },
-        "required": ["path"],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **kwargs: Any) -> str:
-        path_str = args["path"]
-        real_path = Path(path_str)
-        on_output: Callable[[str], None] | None = kwargs.get("on_output")
-
-        if real_path.is_dir():
-            try:
-                entries = []
-                stream_buffer: list[str] = []
-                stream_size = 0
-                for entry in sorted(os.listdir(real_path)):
-                    full = real_path / entry
-                    kind = "dir" if full.is_dir() else "file"
-                    size = full.stat().st_size if kind == "file" else None
-                    entries.append({"name": entry, "type": kind, "size": size})
-                    label = f"{kind}\t{entry}"
-                    if size is not None:
-                        label = f"{label}\t{size}"
-                    stream_size = _append_stream_chunk(
-                        stream_buffer,
-                        stream_size,
-                        f"{label}\n",
-                        on_output,
-                    )
-                _flush_stream_chunk(stream_buffer, on_output)
-                logger.debug(
-                    "Listed directory: {} ({} entries)", path_str, len(entries)
-                )
-                return json.dumps({"path": path_str, "entries": entries})
-            except Exception as e:
-                re_raise_interrupt(agent, e)
-                return json.dumps({"error": str(e)})
-
-        if real_path.is_file():
-            try:
-                with open(real_path, encoding="utf-8") as f:
-                    total_lines = sum(1 for _ in f)
-
-                start = max(1, int(args.get("start_line", 1)))
-                end = min(total_lines, int(args.get("end_line", total_lines)))
-                width = max(6, len(str(total_lines)))
-                selected_parts: list[str] = []
-                stream_buffer = []
-                stream_size = 0
-
-                with open(real_path, encoding="utf-8") as f:
-                    for line_number, line in enumerate(f, start=1):
-                        if line_number < start:
-                            continue
-                        if line_number > end:
-                            break
-                        numbered_line = f"{line_number:{width}d}\t{line}"
-                        selected_parts.append(numbered_line)
-                        stream_size = _append_stream_chunk(
-                            stream_buffer,
-                            stream_size,
-                            numbered_line,
-                            on_output,
-                        )
-
-                _flush_stream_chunk(stream_buffer, on_output)
-                numbered = "".join(selected_parts)
-
-                logger.debug(
-                    "Read file: {} (lines {}-{} of {})",
-                    path_str,
-                    start,
-                    end,
-                    total_lines,
-                )
-                return json.dumps(
-                    {
-                        "path": path_str,
-                        "total_lines": total_lines,
-                        "start_line": start,
-                        "end_line": end,
-                        "content": numbered,
-                    }
-                )
-            except Exception as e:
-                re_raise_interrupt(agent, e)
-                return json.dumps({"error": str(e)})
-
-        return json.dumps({"error": f"Not found: {path_str}"})

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

@@ -1,68 +0,0 @@
-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 SendTool(Tool):
-    name = "send"
-    description = "Send to one current contact or output-port path."
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "target": {
-                "type": "string",
-                "description": "One target id, name, or unique short id from contacts.",
-            },
-            "from_output_port_key": {
-                "type": "string",
-                "description": "Source output port key for workflow path sends.",
-            },
-            "to_input_port_key": {
-                "type": "string",
-                "description": "Target input port key for workflow path sends.",
-            },
-            "value": {
-                "description": "Typed value for workflow path sends. Use ordered parts for parts ports, a string for string ports, or an object for json ports.",
-            },
-            "parts": {
-                "type": "array",
-                "description": "Ordered message parts for Assistant and Leader entry contacts.",
-                "items": {
-                    "type": "object",
-                    "properties": {
-                        "type": {"type": "string", "enum": ["text", "image"]},
-                        "text": {"type": "string"},
-                        "asset_id": {"type": "string"},
-                        "mime_type": {"type": "string"},
-                        "width": {"type": "integer"},
-                        "height": {"type": "integer"},
-                        "alt": {"type": "string"},
-                    },
-                    "required": ["type"],
-                },
-            },
-        },
-        "required": ["target"],
-        "additionalProperties": False,
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        target = args.get("target")
-        if not isinstance(target, str) or not target.strip():
-            raise ValueError("send.target must be a non-empty string")
-        if not agent._is_entry_level_sender():
-            return agent.send_port_value(
-                target_ref=target.strip(),
-                from_output_port_key=args.get("from_output_port_key"),
-                to_input_port_key=args.get("to_input_port_key"),
-                raw_value=args.get("value", args.get("parts")),
-            )
-        return agent.send_message(
-            target_ref=target.strip(),
-            raw_parts=args.get("parts"),
-        )

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

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, Any, ClassVar
-
-from flowent.models import NodeType
-from flowent.tools import Tool
-
-if TYPE_CHECKING:
-    from flowent.agent import Agent
-
-
-class SetPermissionsTool(Tool):
-    name = "set_permissions"
-    description = (
-        "Update a workflow's permission boundary by patching its allow_network "
-        "and write_dirs."
-    )
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "workflow_id": {
-                "type": "string",
-                "description": "ID of the workflow whose permission boundary should be updated",
-            },
-            "allow_network": {
-                "type": "boolean",
-                "description": "Optional patched network permission for the workflow boundary",
-            },
-            "write_dirs": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "Optional patched writable directory boundary for the workflow",
-            },
-        },
-        "required": ["workflow_id"],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        from flowent.graph_service import (
-            resolve_effective_permissions_for_agent,
-            set_tab_permissions,
-        )
-        from flowent.settings import (
-            build_assistant_allow_network,
-            build_assistant_write_dirs,
-        )
-
-        workflow_id = args.get("workflow_id")
-        raw_allow_network = args.get("allow_network")
-        raw_write_dirs = args.get("write_dirs")
-
-        if not isinstance(workflow_id, str) or not workflow_id.strip():
-            return json.dumps({"error": "workflow_id must be a non-empty string"})
-        normalized_workflow_id = workflow_id.strip()
-        if (
-            agent.node_type != NodeType.ASSISTANT
-            and agent.config.tab_id != normalized_workflow_id
-        ):
-            return json.dumps(
-                {"error": "Workflow permissions can only be changed for this workflow"}
-            )
-
-        allow_network: bool | None = None
-        if "allow_network" in args:
-            try:
-                allow_network = build_assistant_allow_network(
-                    raw_allow_network,
-                    field_name="allow_network",
-                )
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-
-        write_dirs: list[str] | None = None
-        if "write_dirs" in args:
-            try:
-                write_dirs = build_assistant_write_dirs(
-                    raw_write_dirs,
-                    field_name="write_dirs",
-                )
-            except ValueError as exc:
-                return json.dumps({"error": str(exc)})
-
-        caller_allow_network, caller_write_dirs = (
-            resolve_effective_permissions_for_agent(agent)
-        )
-        result, error = set_tab_permissions(
-            tab_id=normalized_workflow_id,
-            allow_network=allow_network,
-            write_dirs=write_dirs,
-            caller_allow_network=caller_allow_network,
-            caller_write_dirs=caller_write_dirs,
-            actor_id=agent.uuid,
-        )
-        if error is not None or result is None:
-            return json.dumps(
-                {"error": error or "Failed to update workflow permissions"}
-            )
-        return json.dumps(result)

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

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-import json
-from math import isfinite
-from typing import TYPE_CHECKING, Any, ClassVar
-
-from flowent.tools import Tool
-
-if TYPE_CHECKING:
-    from flowent.agent import Agent
-
-
-class SleepTool(Tool):
-    name = "sleep"
-    description = (
-        "Enter a timed wait that resumes on whichever happens first: a new input "
-        "arrives or the requested duration elapses. Use this when you want to wait "
-        "until a deadline without missing messages."
-    )
-    parameters: ClassVar[dict[str, Any]] = {
-        "type": "object",
-        "properties": {
-            "seconds": {
-                "type": "number",
-                "description": "How many seconds to wait before resuming execution. Supports fractional seconds.",
-                "minimum": 0,
-            }
-        },
-        "required": ["seconds"],
-    }
-
-    def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        seconds = args.get("seconds")
-        if isinstance(seconds, bool) or not isinstance(seconds, int | float):
-            return json.dumps({"error": "seconds must be a non-negative number"})
-
-        duration = float(seconds)
-        if not isfinite(duration) or duration < 0:
-            return json.dumps({"error": "seconds must be a non-negative number"})
-
-        return agent.request_sleep(seconds=duration)