flowent 0.0.7 → 0.0.11

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

@@ -1,379 +0,0 @@
-from __future__ import annotations
-
-import time
-from copy import deepcopy
-from dataclasses import dataclass
-
-from fastapi import APIRouter, HTTPException
-from loguru import logger
-from pydantic import BaseModel, ConfigDict
-
-from flowent.access import initialize_live_access_signature, set_access_code
-from flowent.events import event_bus
-from flowent.settings import (
-    TelegramApprovedChat,
-    TelegramSettings,
-    get_settings,
-    save_settings,
-    serialize_provider,
-    serialize_role,
-    serialize_settings,
-    serialize_telegram_settings,
-)
-from flowent.settings_management import (
-    MISSING,
-    apply_resolved_settings_update,
-    resolve_settings_update,
-)
-
-router = APIRouter()
-
-
-@router.get("/api/settings/bootstrap")
-async def get_settings_bootstrap() -> dict[str, object]:
-    from flowent._version import __version__
-
-    settings = get_settings()
-    return {
-        "settings": serialize_settings(settings),
-        "providers": [serialize_provider(provider) for provider in settings.providers],
-        "roles": [serialize_role(role) for role in settings.roles],
-        "version": __version__,
-    }
-
-
-@router.get("/api/settings")
-async def get_settings_api() -> dict[str, object]:
-    settings = get_settings()
-    return serialize_settings(settings)
-
-
-class UpdateSettingsRequest(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    access: dict[str, object] | None = None
-    assistant: dict[str, object] | None = None
-    event_log: dict[str, object] | None = None
-    leader: dict[str, object] | None = None
-    model: dict[str, object] | None = None
-    working_dir: str | None = None
-
-
-class UpdateTelegramSettingsRequest(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    bot_token: str | None = None
-
-
-@dataclass(frozen=True, slots=True)
-class AssistantSettingsPatch:
-    role_name: str | None = None
-    allow_network: object = MISSING
-    write_dirs: object = MISSING
-
-
-@dataclass(frozen=True, slots=True)
-class ModelSettingsPatch:
-    active_provider_id: str | None = None
-    active_model: str | None = None
-    context_window_tokens: object = MISSING
-    input_image: object = MISSING
-    output_image: object = MISSING
-    structured_output: object = MISSING
-    timeout_ms: object = MISSING
-    retry_policy: object = MISSING
-    max_retries: object = MISSING
-    retry_initial_delay_seconds: object = MISSING
-    retry_max_delay_seconds: object = MISSING
-    retry_backoff_cap_retries: object = MISSING
-    auto_compact_token_limit: object = MISSING
-    params: object = MISSING
-
-
-def _extract_access_code_rotation(access: dict[str, object] | None) -> str | None:
-    if access is None:
-        return None
-
-    raw_new_code = access.get("new_code", "")
-    raw_confirm_code = access.get("confirm_code", "")
-    if raw_new_code is not None and not isinstance(raw_new_code, str):
-        raise HTTPException(status_code=400, detail="access.new_code must be a string")
-    if raw_confirm_code is not None and not isinstance(raw_confirm_code, str):
-        raise HTTPException(
-            status_code=400,
-            detail="access.confirm_code must be a string",
-        )
-
-    new_code = raw_new_code if isinstance(raw_new_code, str) else ""
-    confirm_code = raw_confirm_code if isinstance(raw_confirm_code, str) else ""
-    if not new_code and not confirm_code:
-        return None
-    if not new_code.strip():
-        raise HTTPException(
-            status_code=400,
-            detail="access.new_code must not be empty",
-        )
-    if confirm_code != new_code:
-        raise HTTPException(
-            status_code=400,
-            detail="access.confirm_code must match access.new_code",
-        )
-    return new_code
-
-
-def _extract_assistant_settings_patch(
-    assistant: dict[str, object] | None,
-) -> AssistantSettingsPatch:
-    if assistant is None:
-        return AssistantSettingsPatch()
-
-    unknown_fields = sorted(
-        set(assistant) - {"role_name", "allow_network", "write_dirs"}
-    )
-    if unknown_fields:
-        raise HTTPException(
-            status_code=400,
-            detail="Unknown assistant fields: " + ", ".join(unknown_fields),
-        )
-
-    raw_role_name = assistant.get("role_name")
-    return AssistantSettingsPatch(
-        role_name=(
-            raw_role_name
-            if isinstance(raw_role_name, str) and raw_role_name.strip()
-            else None
-        ),
-        allow_network=(
-            assistant.get("allow_network") if "allow_network" in assistant else MISSING
-        ),
-        write_dirs=assistant.get("write_dirs")
-        if "write_dirs" in assistant
-        else MISSING,
-    )
-
-
-def _extract_role_name(payload: dict[str, object] | None) -> str | None:
-    if payload is None:
-        return None
-    raw_role_name = payload.get("role_name")
-    if isinstance(raw_role_name, str) and raw_role_name.strip():
-        return raw_role_name
-    return None
-
-
-def _extract_timestamp_format(payload: dict[str, object] | None) -> str | None:
-    if payload is None:
-        return None
-    raw_timestamp_format = payload.get("timestamp_format")
-    return raw_timestamp_format if isinstance(raw_timestamp_format, str) else None
-
-
-def _extract_model_settings_patch(
-    model: dict[str, object] | None,
-) -> ModelSettingsPatch:
-    if model is None:
-        return ModelSettingsPatch()
-
-    raw_active_provider_id = model.get("active_provider_id")
-    raw_active_model = model.get("active_model")
-    return ModelSettingsPatch(
-        active_provider_id=(
-            raw_active_provider_id if isinstance(raw_active_provider_id, str) else None
-        ),
-        active_model=raw_active_model if isinstance(raw_active_model, str) else None,
-        context_window_tokens=(
-            model.get("context_window_tokens")
-            if "context_window_tokens" in model
-            else MISSING
-        ),
-        input_image=model.get("input_image") if "input_image" in model else MISSING,
-        output_image=model.get("output_image") if "output_image" in model else MISSING,
-        structured_output=(
-            model.get("structured_output") if "structured_output" in model else MISSING
-        ),
-        timeout_ms=model.get("timeout_ms") if "timeout_ms" in model else MISSING,
-        retry_policy=model.get("retry_policy") if "retry_policy" in model else MISSING,
-        max_retries=model.get("max_retries") if "max_retries" in model else MISSING,
-        retry_initial_delay_seconds=(
-            model.get("retry_initial_delay_seconds")
-            if "retry_initial_delay_seconds" in model
-            else MISSING
-        ),
-        retry_max_delay_seconds=(
-            model.get("retry_max_delay_seconds")
-            if "retry_max_delay_seconds" in model
-            else MISSING
-        ),
-        retry_backoff_cap_retries=(
-            model.get("retry_backoff_cap_retries")
-            if "retry_backoff_cap_retries" in model
-            else MISSING
-        ),
-        auto_compact_token_limit=(
-            model.get("auto_compact_token_limit")
-            if "auto_compact_token_limit" in model
-            else MISSING
-        ),
-        params=model.get("params") if "params" in model else MISSING,
-    )
-
-
-@router.post("/api/settings")
-async def update_settings(req: UpdateSettingsRequest) -> dict[str, object]:
-    from flowent.graph_service import sync_assistant_role, sync_tab_leaders
-    from flowent.providers.gateway import gateway
-
-    source_settings = get_settings()
-    current = deepcopy(source_settings)
-    next_access_code = _extract_access_code_rotation(req.access)
-    reauth_required = False
-    assistant_patch = _extract_assistant_settings_patch(req.assistant)
-    leader_role_name = _extract_role_name(req.leader)
-    timestamp_format = _extract_timestamp_format(req.event_log)
-    model_patch = _extract_model_settings_patch(req.model)
-
-    try:
-        resolved = resolve_settings_update(
-            current,
-            working_dir=req.working_dir,
-            assistant_role_name=assistant_patch.role_name,
-            assistant_allow_network=assistant_patch.allow_network,
-            assistant_write_dirs=assistant_patch.write_dirs,
-            leader_role_name=leader_role_name,
-            active_provider_id=model_patch.active_provider_id,
-            active_model=model_patch.active_model,
-            context_window_tokens=model_patch.context_window_tokens,
-            input_image=model_patch.input_image,
-            output_image=model_patch.output_image,
-            structured_output=model_patch.structured_output,
-            max_retries=model_patch.max_retries,
-            retry_policy=model_patch.retry_policy,
-            timeout_ms=model_patch.timeout_ms,
-            retry_initial_delay_seconds=model_patch.retry_initial_delay_seconds,
-            retry_max_delay_seconds=model_patch.retry_max_delay_seconds,
-            retry_backoff_cap_retries=model_patch.retry_backoff_cap_retries,
-            auto_compact_token_limit=model_patch.auto_compact_token_limit,
-            model_params=model_patch.params,
-            timestamp_format=timestamp_format,
-        )
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-    apply_resolved_settings_update(current, resolved)
-
-    if next_access_code is not None:
-        set_access_code(current, next_access_code)
-        reauth_required = True
-
-    save_settings(current)
-    source_settings.__dict__.clear()
-    source_settings.__dict__.update(deepcopy(current).__dict__)
-    initialize_live_access_signature()
-    try:
-        sync_assistant_role(reason="assistant settings updated")
-        sync_tab_leaders(reason="leader settings updated")
-        gateway.invalidate_cache()
-    except Exception:
-        logger.exception("Settings saved but runtime synchronization failed")
-    if reauth_required:
-        event_bus.close_all_connections(code=4001, reason="Access code rotated")
-    logger.info("Settings updated")
-    return {
-        "status": "saved",
-        "settings": serialize_settings(current),
-        "reauth_required": reauth_required,
-    }
-
-
-@router.get("/api/settings/telegram")
-async def get_telegram_settings() -> dict[str, object]:
-    settings = get_settings()
-    return serialize_telegram_settings(settings.telegram)
-
-
-@router.patch("/api/settings/telegram")
-async def update_telegram_settings(
-    req: UpdateTelegramSettingsRequest,
-) -> dict[str, object]:
-    from flowent.runtime import restart_telegram_channel
-
-    settings = get_settings()
-    previous_token = settings.telegram.bot_token
-
-    next_token = previous_token
-    if req.bot_token is not None:
-        next_token = req.bot_token.strip()
-
-    settings.telegram = TelegramSettings(
-        bot_token=next_token,
-        pending_chats=list(settings.telegram.pending_chats),
-        approved_chats=list(settings.telegram.approved_chats),
-    )
-    save_settings(settings)
-
-    if next_token != previous_token:
-        restart_telegram_channel()
-
-    logger.info("Telegram settings updated")
-    return {
-        "status": "saved",
-        "telegram": serialize_telegram_settings(settings.telegram),
-    }
-
-
-@router.post("/api/settings/telegram/approve/{chat_id}")
-async def approve_telegram_chat(chat_id: int) -> dict[str, object]:
-    settings = get_settings()
-    pending_chat = next(
-        (chat for chat in settings.telegram.pending_chats if chat.chat_id == chat_id),
-        None,
-    )
-    if pending_chat is None:
-        raise HTTPException(status_code=404, detail="Pending Telegram chat not found")
-
-    settings.telegram.pending_chats = [
-        chat for chat in settings.telegram.pending_chats if chat.chat_id != chat_id
-    ]
-    if not any(chat.chat_id == chat_id for chat in settings.telegram.approved_chats):
-        settings.telegram.approved_chats.append(
-            TelegramApprovedChat(
-                chat_id=pending_chat.chat_id,
-                username=pending_chat.username,
-                display_name=pending_chat.display_name,
-                approved_at=time.time(),
-            )
-        )
-    save_settings(settings)
-    logger.info("Telegram chat approved: {}", chat_id)
-    return {
-        "status": "approved",
-        "telegram": serialize_telegram_settings(settings.telegram),
-    }
-
-
-@router.delete("/api/settings/telegram/pending/{chat_id}")
-async def delete_pending_telegram_chat(chat_id: int) -> dict[str, object]:
-    settings = get_settings()
-    settings.telegram.pending_chats = [
-        chat for chat in settings.telegram.pending_chats if chat.chat_id != chat_id
-    ]
-    save_settings(settings)
-    logger.info("Pending Telegram chat removed: {}", chat_id)
-    return {
-        "status": "deleted",
-        "telegram": serialize_telegram_settings(settings.telegram),
-    }
-
-
-@router.delete("/api/settings/telegram/chat/{chat_id}")
-async def delete_telegram_chat(chat_id: int) -> dict[str, object]:
-    settings = get_settings()
-    settings.telegram.approved_chats = [
-        existing_chat
-        for existing_chat in settings.telegram.approved_chats
-        if existing_chat.chat_id != chat_id
-    ]
-    save_settings(settings)
-    logger.info("Telegram chat removed: {}", chat_id)
-    return {
-        "status": "deleted",
-        "telegram": serialize_telegram_settings(settings.telegram),
-    }

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

@@ -1,298 +0,0 @@
-from __future__ import annotations
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, ConfigDict
-
-from flowent.graph_service import (
-    activate_tab,
-    create_agent_node,
-    create_edge,
-    create_graph_node,
-    create_tab,
-    deactivate_tab,
-    delete_agent_node,
-    delete_edge,
-    delete_tab,
-    list_node_connection_ids,
-    list_tab_edges,
-    list_workflow_nodes,
-    serialize_tab_summary,
-    update_tab_definition,
-)
-from flowent.models import AgentState, WorkflowNodeKind
-from flowent.registry import registry
-from flowent.workspace_store import workspace_store
-
-router = APIRouter()
-
-
-class CreateTabRequest(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    title: str
-    allow_network: bool = False
-    write_dirs: list[str] = []
-
-
-class CreateTabNodeRequest(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    node_type: str = WorkflowNodeKind.AGENT.value
-    role_name: str | None = None
-    name: str | None = None
-    config: dict[str, object] = {}
-    tools: list[str] = []
-
-
-class CreateTabEdgeRequest(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    from_node_id: str
-    from_port_key: str = "out"
-    to_node_id: str
-    to_port_key: str = "in"
-    kind: str | None = None
-
-
-class UpdateTabDefinitionRequest(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    definition: dict[str, object]
-
-
-def _serialize_workflow_node(
-    *,
-    tab_id: str,
-    node_id: str,
-) -> dict[str, object]:
-    tab = workspace_store.get_tab(tab_id)
-    if tab is None:
-        raise HTTPException(status_code=404, detail="Workflow not found")
-    definition = tab.definition.get_node(node_id)
-    if definition is None:
-        raise HTTPException(status_code=404, detail="Node not found")
-    record = workspace_store.get_node_record(node_id)
-    live_node = registry.get(node_id)
-    config = dict(definition.config)
-    role_name = config.get("role_name")
-    name = config.get("name")
-    position = tab.definition.view.positions.get(node_id)
-    todos = (
-        [todo.serialize() for todo in live_node.get_todos_snapshot()]
-        if live_node is not None
-        else [todo.serialize() for todo in (record.todos if record is not None else [])]
-    )
-    state = (
-        live_node.state.value
-        if live_node is not None
-        else (record.state.value if record is not None else AgentState.IDLE.value)
-    )
-    return {
-        "id": definition.id,
-        "node_type": definition.type.value,
-        "workflow_id": tab_id,
-        "role_name": role_name if isinstance(role_name, str) else None,
-        "is_leader": False,
-        "state": state,
-        "connections": list_node_connection_ids(tab_id=tab_id, node_id=definition.id)
-        if definition.type == WorkflowNodeKind.AGENT
-        else [],
-        "name": name if isinstance(name, str) else None,
-        "todos": todos if definition.type == WorkflowNodeKind.AGENT else [],
-        "position": position.serialize() if position is not None else None,
-        "config": config,
-        "inputs": [port.serialize() for port in definition.inputs],
-        "outputs": [port.serialize() for port in definition.outputs],
-    }
-
-
-@router.get("/api/workflows")
-async def list_workflows() -> dict[str, object]:
-    tabs = workspace_store.list_tabs()
-    return {"workflows": [serialize_tab_summary(tab) for tab in tabs]}
-
-
-@router.post("/api/workflows")
-async def create_workflow_route(req: CreateTabRequest) -> dict[str, object]:
-    title = req.title.strip()
-    if not title:
-        raise HTTPException(status_code=400, detail="title must not be empty")
-    try:
-        tab = create_tab(
-            title=title,
-            allow_network=req.allow_network,
-            write_dirs=req.write_dirs,
-        )
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail=str(exc)) from exc
-    return serialize_tab_summary(tab)
-
-
-@router.post("/api/workflows/{tab_id}/activate")
-async def activate_workflow_route(tab_id: str) -> dict[str, object]:
-    updated, errors, error = activate_tab(tab_id=tab_id, actor_id=tab_id)
-    if errors:
-        raise HTTPException(status_code=400, detail={"errors": errors})
-    if error is not None or updated is None:
-        raise HTTPException(
-            status_code=404 if error and error.endswith("not found") else 400,
-            detail=error or "Failed to activate workflow",
-        )
-    return serialize_tab_summary(updated)
-
-
-@router.post("/api/workflows/{tab_id}/deactivate")
-async def deactivate_workflow_route(tab_id: str) -> dict[str, object]:
-    updated, error = deactivate_tab(tab_id=tab_id, actor_id=tab_id)
-    if error is not None or updated is None:
-        raise HTTPException(
-            status_code=404 if error and error.endswith("not found") else 400,
-            detail=error or "Failed to deactivate workflow",
-        )
-    return serialize_tab_summary(updated)
-
-
-@router.get("/api/workflows/{tab_id}")
-async def get_workflow(tab_id: str) -> dict[str, object]:
-    tab = workspace_store.get_tab(tab_id)
-    if tab is None:
-        raise HTTPException(status_code=404, detail="Workflow not found")
-    nodes = [
-        _serialize_workflow_node(tab_id=tab_id, node_id=node.id)
-        for node in list_workflow_nodes(tab_id)
-    ]
-    edges = [edge.serialize() for edge in list_tab_edges(tab_id)]
-    return {
-        "workflow": serialize_tab_summary(tab),
-        "nodes": nodes,
-        "edges": edges,
-    }
-
-
-@router.put("/api/workflows/{tab_id}/definition")
-async def update_workflow_definition_route(
-    tab_id: str,
-    req: UpdateTabDefinitionRequest,
-) -> dict[str, object]:
-    updated, error = update_tab_definition(
-        tab_id=tab_id,
-        definition_payload=req.definition,
-        actor_id=tab_id,
-    )
-    if error is not None or updated is None:
-        raise HTTPException(
-            status_code=400 if error and not error.endswith("not found") else 404,
-            detail=error or "Failed to update workflow definition",
-        )
-    return serialize_tab_summary(updated)
-
-
-@router.delete("/api/workflows/{tab_id}")
-async def delete_workflow_route(tab_id: str) -> dict[str, object]:
-    deleted, error = delete_tab(tab_id=tab_id)
-    if error is not None or deleted is None:
-        status_code = 404 if error and error.endswith("not found") else 400
-        raise HTTPException(
-            status_code=status_code,
-            detail=error or "Failed to delete workflow",
-        )
-    return deleted
-
-
-@router.post("/api/workflows/{tab_id}/nodes")
-async def create_workflow_node(
-    tab_id: str,
-    req: CreateTabNodeRequest,
-) -> dict[str, object]:
-    try:
-        node_type = WorkflowNodeKind(req.node_type.strip())
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail="Invalid node_type") from exc
-
-    if node_type == WorkflowNodeKind.AGENT:
-        if not isinstance(req.role_name, str) or not req.role_name.strip():
-            raise HTTPException(status_code=400, detail="role_name is required")
-        record, error = create_agent_node(
-            role_name=req.role_name,
-            tab_id=tab_id,
-            name=req.name,
-            tools=req.tools,
-        )
-        if error is not None or record is None:
-            raise HTTPException(
-                status_code=400, detail=error or "Failed to create node"
-            )
-        return _serialize_workflow_node(tab_id=tab_id, node_id=record.id)
-
-    node, error = create_graph_node(
-        tab_id=tab_id,
-        node_type=node_type,
-        config={
-            **req.config,
-            **(
-                {"name": req.name}
-                if isinstance(req.name, str) and req.name.strip()
-                else {}
-            ),
-        },
-        actor_id=tab_id,
-    )
-    if error is not None or node is None:
-        raise HTTPException(status_code=400, detail=error or "Failed to create node")
-    return _serialize_workflow_node(tab_id=tab_id, node_id=node.id)
-
-
-@router.post("/api/workflows/{tab_id}/edges")
-async def create_workflow_edge(
-    tab_id: str,
-    req: CreateTabEdgeRequest,
-) -> dict[str, object]:
-    tab = workspace_store.get_tab(tab_id)
-    if tab is None:
-        raise HTTPException(status_code=404, detail="Workflow not found")
-    edge, error = create_edge(
-        tab_id=tab_id,
-        from_node_id=req.from_node_id,
-        from_port_key=req.from_port_key,
-        to_node_id=req.to_node_id,
-        to_port_key=req.to_port_key,
-        kind=req.kind or "",
-    )
-    if error is not None or edge is None:
-        raise HTTPException(status_code=400, detail=error or "Failed to create edge")
-    return edge.serialize()
-
-
-@router.delete("/api/workflows/{tab_id}/nodes/{node_id}")
-async def delete_workflow_node(tab_id: str, node_id: str) -> dict[str, object]:
-    deleted, error = delete_agent_node(
-        tab_id=tab_id,
-        node_id=node_id,
-    )
-    if error is not None or deleted is None:
-        status_code = 404 if error and error.endswith("not found") else 400
-        raise HTTPException(
-            status_code=status_code, detail=error or "Failed to delete node"
-        )
-    return deleted
-
-
-@router.delete("/api/workflows/{tab_id}/edges")
-async def delete_workflow_edge(
-    tab_id: str,
-    edge_id: str | None = None,
-    from_node_id: str | None = None,
-    to_node_id: str | None = None,
-    from_port_key: str | None = None,
-    to_port_key: str | None = None,
-) -> dict[str, object]:
-    deleted, error = delete_edge(
-        tab_id=tab_id,
-        edge_id=edge_id,
-        from_node_id=from_node_id,
-        to_node_id=to_node_id,
-        from_port_key=from_port_key,
-        to_port_key=to_port_key,
-    )
-    if error is not None or deleted is None:
-        status_code = 404 if error and error.endswith("not found") else 400
-        raise HTTPException(
-            status_code=status_code, detail=error or "Failed to delete edge"
-        )
-    return deleted

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

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-from fastapi import APIRouter
-from starlette.websockets import WebSocket, WebSocketDisconnect
-
-from flowent.access import authorize_websocket
-from flowent.events import event_bus
-
-router = APIRouter()
-
-
-@router.websocket("/ws/events")
-async def ws_events(ws: WebSocket) -> None:
-    if not await authorize_websocket(ws):
-        return
-    await event_bus.connect_display(ws)
-    try:
-        while True:
-            await ws.receive_text()
-    except WebSocketDisconnect:
-        event_bus.disconnect_display(ws)
-
-
-@router.websocket("/ws/updates")
-async def ws_updates(ws: WebSocket) -> None:
-    if not await authorize_websocket(ws):
-        return
-    await event_bus.connect_updates(ws)
-    try:
-        while True:
-            await ws.receive_text()
-    except WebSocketDisconnect:
-        event_bus.disconnect_updates(ws)