flowent 0.0.7 → 0.0.10

package/backend/src/flowent/providers/registry.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-from enum import StrEnum
-from typing import Protocol
-
-from flowent.providers import LLMProvider
-from flowent.providers.base_url import resolve_provider_base_url
-
-
-class ProviderType(StrEnum):
-    OPENAI_COMPATIBLE = "openai_compatible"
-    OPENAI_RESPONSES = "openai_responses"
-    ANTHROPIC = "anthropic"
-    GEMINI = "gemini"
-
-
-class ProviderFactory(Protocol):
-    def __call__(
-        self,
-        *,
-        provider_name: str,
-        api_base_url: str,
-        api_key: str,
-        headers: dict[str, str],
-        model: str,
-        request_timeout_seconds: float,
-    ) -> LLMProvider: ...
-
-
-def _build_openai_compatible_provider(
-    *,
-    provider_name: str,
-    api_base_url: str,
-    api_key: str,
-    headers: dict[str, str],
-    model: str,
-    request_timeout_seconds: float,
-) -> LLMProvider:
-    from flowent.providers.openai import OpenAIProvider
-
-    return OpenAIProvider(
-        provider_name=provider_name,
-        api_base_url=api_base_url,
-        api_key=api_key,
-        headers=headers,
-        model=model,
-        request_timeout_seconds=request_timeout_seconds,
-    )
-
-
-def _build_openai_responses_provider(
-    *,
-    provider_name: str,
-    api_base_url: str,
-    api_key: str,
-    headers: dict[str, str],
-    model: str,
-    request_timeout_seconds: float,
-) -> LLMProvider:
-    from flowent.providers.openai_responses import OpenAIResponsesProvider
-
-    return OpenAIResponsesProvider(
-        provider_name=provider_name,
-        api_base_url=api_base_url,
-        api_key=api_key,
-        headers=headers,
-        model=model,
-        request_timeout_seconds=request_timeout_seconds,
-    )
-
-
-def _build_anthropic_provider(
-    *,
-    provider_name: str,
-    api_base_url: str,
-    api_key: str,
-    headers: dict[str, str],
-    model: str,
-    request_timeout_seconds: float,
-) -> LLMProvider:
-    from flowent.providers.anthropic import AnthropicProvider
-
-    return AnthropicProvider(
-        provider_name=provider_name,
-        api_base_url=api_base_url,
-        api_key=api_key,
-        headers=headers,
-        model=model,
-        request_timeout_seconds=request_timeout_seconds,
-    )
-
-
-def _build_gemini_provider(
-    *,
-    provider_name: str,
-    api_base_url: str,
-    api_key: str,
-    headers: dict[str, str],
-    model: str,
-    request_timeout_seconds: float,
-) -> LLMProvider:
-    from flowent.providers.gemini import GeminiProvider
-
-    return GeminiProvider(
-        provider_name=provider_name,
-        api_base_url=api_base_url,
-        api_key=api_key,
-        headers=headers,
-        model=model,
-        request_timeout_seconds=request_timeout_seconds,
-    )
-
-
-PROVIDER_FACTORIES: dict[ProviderType, ProviderFactory] = {
-    ProviderType.OPENAI_COMPATIBLE: _build_openai_compatible_provider,
-    ProviderType.OPENAI_RESPONSES: _build_openai_responses_provider,
-    ProviderType.ANTHROPIC: _build_anthropic_provider,
-    ProviderType.GEMINI: _build_gemini_provider,
-}
-
-
-def create_provider(
-    provider_type: str,
-    base_url: str,
-    api_key: str = "",
-    headers: dict[str, str] | None = None,
-    model: str = "",
-    provider_name: str = "",
-    request_timeout_seconds: float = 120.0,
-) -> LLMProvider:
-    try:
-        normalized_type = ProviderType(provider_type.lower())
-    except ValueError as exc:
-        raise ValueError(f"Unknown provider type: {provider_type}") from exc
-
-    resolved_base_url = resolve_provider_base_url(normalized_type, base_url)
-    return PROVIDER_FACTORIES[normalized_type](
-        provider_name=provider_name,
-        api_base_url=resolved_base_url,
-        api_key=api_key,
-        headers=headers or {},
-        model=model,
-        request_timeout_seconds=request_timeout_seconds,
-    )

package/backend/src/flowent/providers/sse.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-import json
-from collections.abc import Iterator
-from typing import Any
-
-from flowent.network import iter_response_lines
-
-
-def iter_sse_data(response: Any) -> Iterator[str]:
-    for line in iter_response_lines(response):
-        if not line or line.startswith(":"):
-            continue
-        if not line.startswith("data: "):
-            continue
-        yield line[6:]
-
-
-def iter_sse_json(
-    response: Any,
-    done_token: str | None = None,
-) -> Iterator[dict[str, Any]]:
-    for payload in iter_sse_data(response):
-        if done_token is not None and payload.strip() == done_token:
-            break
-        try:
-            parsed = json.loads(payload)
-        except json.JSONDecodeError:
-            continue
-        if isinstance(parsed, dict):
-            yield parsed

package/backend/src/flowent/providers/thinking.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-
-class ThinkTagParser:
-    OPEN_TAG = "<think>"
-    CLOSE_TAG = "</think>"
-
-    def __init__(self) -> None:
-        self._inside = False
-        self._pending = ""
-        self._skip_newlines = False
-
-    def feed(self, text: str) -> list[tuple[str, str]]:
-        if self._skip_newlines:
-            text = text.lstrip("\n")
-            if not text:
-                return []
-            self._skip_newlines = False
-        self._pending += text
-        return self._drain()
-
-    def flush(self) -> list[tuple[str, str]]:
-        if not self._pending:
-            return []
-        chunk_type = "thinking" if self._inside else "content"
-        result = [(chunk_type, self._pending)]
-        self._pending = ""
-        return result
-
-    def _drain(self) -> list[tuple[str, str]]:
-        results: list[tuple[str, str]] = []
-        while self._pending:
-            tag = self.CLOSE_TAG if self._inside else self.OPEN_TAG
-            idx = self._pending.find(tag)
-            if idx >= 0:
-                before = self._pending[:idx]
-                if before:
-                    chunk_type = "thinking" if self._inside else "content"
-                    results.append((chunk_type, before))
-                self._pending = self._pending[idx + len(tag) :]
-                self._inside = not self._inside
-                self._pending = self._pending.lstrip("\n")
-                if not self._pending:
-                    self._skip_newlines = True
-                continue
-
-            for n in range(min(len(tag) - 1, len(self._pending)), 0, -1):
-                if self._pending.endswith(tag[:n]):
-                    safe = self._pending[:-n]
-                    if safe:
-                        chunk_type = "thinking" if self._inside else "content"
-                        results.append((chunk_type, safe))
-                    self._pending = self._pending[-n:]
-                    return results
-
-            chunk_type = "thinking" if self._inside else "content"
-            results.append((chunk_type, self._pending))
-            self._pending = ""
-
-        return results
-
-
-def split_thinking_content(text: str) -> tuple[str, str]:
-    parser = ThinkTagParser()
-    chunks = parser.feed(text)
-    chunks.extend(parser.flush())
-
-    content_parts: list[str] = []
-    thinking_parts: list[str] = []
-
-    for chunk_type, chunk_text in chunks:
-        if not chunk_text:
-            continue
-        if chunk_type == "thinking":
-            thinking_parts.append(chunk_text)
-        else:
-            content_parts.append(chunk_text)
-
-    return "".join(content_parts), "".join(thinking_parts)

package/backend/src/flowent/registry.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import threading
-from typing import TYPE_CHECKING
-
-from loguru import logger
-
-from flowent.models import NodeType
-
-if TYPE_CHECKING:
-    from flowent.agent import Agent
-
-
-class AgentRegistry:
-    def __init__(self) -> None:
-        self._agents: dict[str, Agent] = {}
-        self._lock = threading.Lock()
-
-    def register(self, agent: Agent) -> None:
-        with self._lock:
-            self._agents[agent.uuid] = agent
-            logger.info(
-                "Node registered: {} (type={})",
-                agent.uuid[:8],
-                agent.config.node_type.value,
-            )
-
-    def unregister(self, agent_id: str) -> None:
-        with self._lock:
-            removed = self._agents.pop(agent_id, None)
-            if removed:
-                logger.info("Node unregistered: {}", agent_id[:8])
-
-    def get(self, agent_id: str) -> Agent | None:
-        with self._lock:
-            return self._agents.get(agent_id)
-
-    def get_assistant(self) -> Agent | None:
-        with self._lock:
-            for agent in self._agents.values():
-                if agent.node_type == NodeType.ASSISTANT:
-                    return agent
-            return None
-
-    def find_by_name(self, name: str) -> Agent | None:
-        with self._lock:
-            matches = [a for a in self._agents.values() if a.config.name == name]
-            if len(matches) == 1:
-                return matches[0]
-            return None
-
-    def find_by_uuid_prefix(self, prefix: str) -> Agent | None:
-        with self._lock:
-            matches = [
-                agent
-                for agent_id, agent in self._agents.items()
-                if agent_id.startswith(prefix)
-            ]
-            if len(matches) == 1:
-                return matches[0]
-            return None
-
-    def get_all(self) -> list[Agent]:
-        with self._lock:
-            return list(self._agents.values())
-
-    def reset(self) -> None:
-        with self._lock:
-            self._agents.clear()
-            logger.debug("Registry reset")
-
-
-registry = AgentRegistry()

package/backend/src/flowent/role_management.py

@@ -1,270 +0,0 @@
-from __future__ import annotations
-
-from flowent.settings import (
-    ModelParams,
-    RoleConfig,
-    RoleModelConfig,
-    Settings,
-    build_model_params_from_mapping,
-    clear_role_references,
-    find_provider,
-    is_builtin_role_name,
-    normalize_tool_names,
-    rename_role_references,
-    validate_role_tool_config,
-)
-
-
-class RoleConflictError(ValueError):
-    pass
-
-
-def find_role_by_name(roles: list[RoleConfig], role_name: str) -> RoleConfig | None:
-    for role in roles:
-        if role.name == role_name:
-            return role
-    return None
-
-
-def require_role_name(value: str) -> str:
-    name = value.strip()
-    if not name:
-        raise ValueError("Role name is required")
-    return name
-
-
-def require_role_description(value: str) -> str:
-    description = value.strip()
-    if not description:
-        raise ValueError("Role description is required")
-    return description
-
-
-def normalize_optional_role_name(value: str | None) -> str | None:
-    if value is None:
-        return None
-    return require_role_name(value)
-
-
-def normalize_optional_role_description(value: str | None) -> str | None:
-    if value is None:
-        return None
-    return require_role_description(value)
-
-
-def ensure_role_name_available(
-    roles: list[RoleConfig],
-    role_name: str,
-    *,
-    current_name: str | None = None,
-) -> None:
-    if any(role.name == role_name and role.name != current_name for role in roles):
-        raise RoleConflictError(f"Role '{role_name}' already exists")
-
-
-def resolve_role_tool_config(
-    current: RoleConfig | None,
-    included_tools: list[str] | None,
-    excluded_tools: list[str] | None,
-) -> tuple[list[str], list[str]]:
-    from flowent.tools import is_assistant_only_tool_name
-
-    next_included = normalize_tool_names(
-        included_tools
-        if included_tools is not None
-        else current.included_tools
-        if current
-        else []
-    )
-    if included_tools is not None:
-        next_included = [
-            tool_name
-            for tool_name in next_included
-            if not tool_name.startswith("mcp__")
-            and not is_assistant_only_tool_name(tool_name)
-        ]
-    next_excluded = normalize_tool_names(
-        excluded_tools
-        if excluded_tools is not None
-        else current.excluded_tools
-        if current
-        else []
-    )
-    if excluded_tools is not None:
-        next_excluded = [
-            tool_name
-            for tool_name in next_excluded
-            if not tool_name.startswith("mcp__")
-        ]
-    validate_role_tool_config(next_included, next_excluded)
-    return next_included, next_excluded
-
-
-def resolve_role_model(
-    requested: object,
-    *,
-    settings: Settings,
-    current: RoleModelConfig | None,
-    provided: bool,
-    invalid_type_error: str,
-    missing_provider_id_error: str,
-    missing_model_error: str,
-) -> RoleModelConfig | None:
-    if not provided:
-        return current
-    if requested is None:
-        return None
-
-    extracted = _extract_role_model_fields(requested)
-    if extracted is None:
-        raise ValueError(invalid_type_error)
-
-    provider_id_value, model_value = extracted
-    if not isinstance(provider_id_value, str) or not provider_id_value.strip():
-        raise ValueError(missing_provider_id_error)
-    if not isinstance(model_value, str) or not model_value.strip():
-        raise ValueError(missing_model_error)
-
-    provider_id = provider_id_value.strip()
-    model = model_value.strip()
-    if find_provider(settings, provider_id) is None:
-        raise ValueError(f"Provider '{provider_id}' not found")
-
-    return RoleModelConfig(provider_id=provider_id, model=model)
-
-
-def resolve_role_model_params(
-    requested: object,
-    *,
-    current: ModelParams | None,
-    provided: bool,
-) -> ModelParams | None:
-    if not provided:
-        return current
-    return build_model_params_from_mapping(requested)
-
-
-def validate_builtin_role_update(
-    role: RoleConfig,
-    *,
-    next_name: str | None,
-    next_description: str | None,
-    next_system_prompt: str | None,
-    next_included_tools: list[str],
-    next_excluded_tools: list[str],
-) -> None:
-    if not is_builtin_role_name(role.name):
-        return
-    if next_name is not None and next_name != role.name:
-        raise ValueError(f"Cannot rename built-in role '{role.name}'")
-    if next_description is not None and next_description != role.description:
-        raise ValueError(
-            f"Cannot modify built-in role '{role.name}' fields other than "
-            "model or model_params"
-        )
-    if next_system_prompt is not None and next_system_prompt != role.system_prompt:
-        raise ValueError(
-            f"Cannot modify built-in role '{role.name}' fields other than "
-            "model or model_params"
-        )
-    if (
-        next_included_tools != role.included_tools
-        or next_excluded_tools != role.excluded_tools
-    ):
-        raise ValueError(
-            f"Cannot modify built-in role '{role.name}' fields other than "
-            "model or model_params"
-        )
-
-
-def build_role_config(
-    *,
-    name: str,
-    description: str,
-    system_prompt: str,
-    model: RoleModelConfig | None,
-    model_params: ModelParams | None,
-    included_tools: list[str],
-    excluded_tools: list[str],
-) -> RoleConfig:
-    return RoleConfig(
-        name=name,
-        description=description,
-        system_prompt=system_prompt,
-        model=model,
-        model_params=model_params,
-        included_tools=included_tools,
-        excluded_tools=excluded_tools,
-    )
-
-
-def apply_role_update(
-    *,
-    settings: Settings,
-    role: RoleConfig,
-    next_name: str | None,
-    next_description: str | None,
-    next_system_prompt: str | None,
-    next_model: RoleModelConfig | None,
-    update_model: bool,
-    next_model_params: ModelParams | None,
-    update_model_params: bool,
-    next_included_tools: list[str],
-    next_excluded_tools: list[str],
-) -> RoleConfig:
-    previous_name = role.name
-    if next_name is not None:
-        role.name = next_name
-        rename_role_references(settings, previous_name, role.name)
-    if next_description is not None:
-        role.description = next_description
-    if next_system_prompt is not None:
-        role.system_prompt = next_system_prompt
-    if update_model:
-        role.model = next_model
-    if update_model_params:
-        role.model_params = next_model_params
-    role.included_tools = next_included_tools
-    role.excluded_tools = next_excluded_tools
-    return role
-
-
-def remove_role(settings: Settings, role: RoleConfig) -> None:
-    settings.roles = [existing for existing in settings.roles if existing is not role]
-    clear_role_references(settings, role.name)
-
-
-def sync_running_system_roles() -> None:
-    from flowent.graph_service import sync_assistant_role, sync_tab_leaders
-
-    sync_assistant_role(reason="assistant role updated")
-    sync_tab_leaders(reason="leader role updated")
-
-
-def _extract_role_model_fields(requested: object) -> tuple[object, object] | None:
-    if isinstance(requested, dict):
-        return requested.get("provider_id"), requested.get("model")
-    provider_id = getattr(requested, "provider_id", None)
-    model = getattr(requested, "model", None)
-    if provider_id is None and model is None:
-        return None
-    return provider_id, model
-
-
-__all__ = [
-    "RoleConflictError",
-    "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",
-]

package/backend/src/flowent/routes/__init__.py

@@ -1,26 +0,0 @@
-from fastapi import APIRouter
-
-from flowent.routes.access import router as access_router
-from flowent.routes.assistant import router as assistant_router
-from flowent.routes.image_assets import router as image_assets_router
-from flowent.routes.meta import router as meta_router
-from flowent.routes.nodes import router as nodes_router
-from flowent.routes.prompts import router as prompts_router
-from flowent.routes.providers_route import router as providers_router
-from flowent.routes.roles import router as roles_router
-from flowent.routes.settings import router as settings_router
-from flowent.routes.tabs import router as tabs_router
-from flowent.routes.ws import router as ws_router
-
-router = APIRouter()
-router.include_router(access_router)
-router.include_router(nodes_router)
-router.include_router(assistant_router)
-router.include_router(image_assets_router)
-router.include_router(roles_router)
-router.include_router(providers_router)
-router.include_router(prompts_router)
-router.include_router(settings_router)
-router.include_router(tabs_router)
-router.include_router(meta_router)
-router.include_router(ws_router)