flowent 0.0.1 → 0.0.4

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

@@ -0,0 +1,144 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,255 @@
+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]]:
+    next_included = normalize_tool_names(
+        included_tools
+        if included_tools is not None
+        else current.included_tools
+        if current
+        else []
+    )
+    next_excluded = normalize_tool_names(
+        excluded_tools
+        if excluded_tools is not None
+        else current.excluded_tools
+        if current
+        else []
+    )
+    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

@@ -0,0 +1,30 @@
+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.mcp import router as mcp_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.stats import router as stats_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(mcp_router)
+router.include_router(roles_router)
+router.include_router(providers_router)
+router.include_router(prompts_router)
+router.include_router(settings_router)
+router.include_router(stats_router)
+router.include_router(tabs_router)
+router.include_router(meta_router)
+router.include_router(ws_router)

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

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+from flowent.access import (
+    ACCESS_SESSION_KEY,
+    build_access_state_payload,
+    is_access_configured,
+    verify_access_code,
+)
+
+router = APIRouter()
+
+
+class AccessLoginRequest(BaseModel):
+    code: str = ""
+
+
+@router.get("/api/access/state")
+async def get_access_state(request: Request) -> dict[str, object]:
+    return build_access_state_payload(request.session)
+
+
+@router.post("/api/access/login")
+async def login_access(
+    payload: AccessLoginRequest,
+    request: Request,
+) -> dict[str, object]:
+    from flowent.access import _read_live_access_settings
+
+    access = _read_live_access_settings()
+    if not is_access_configured(access):
+        raise HTTPException(
+            status_code=503,
+            detail="Access code is not initialized. Restart Flowent to generate a new access code.",
+        )
+    if not verify_access_code(access, payload.code):
+        raise HTTPException(status_code=401, detail="Invalid access code")
+    request.session.clear()
+    request.session[ACCESS_SESSION_KEY] = access.session_generation
+    return build_access_state_payload(request.session)
+
+
+@router.post("/api/access/logout")
+async def logout_access(request: Request) -> dict[str, object]:
+    request.session.clear()
+    return build_access_state_payload(request.session)