flowent 0.0.1 → 0.0.5

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

@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+import time
+from copy import deepcopy
+
+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
+
+
+@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: str | None = None
+    reauth_required = False
+
+    if req.access is not None:
+        raw_new_code = req.access.get("new_code", "")
+        raw_confirm_code = req.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 new_code or confirm_code:
+            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",
+                )
+            next_access_code = new_code
+
+    assistant_role_name: str | None = None
+    assistant_allow_network: object = MISSING
+    assistant_write_dirs: object = MISSING
+    if req.assistant is not None:
+        assistant_unknown_fields = sorted(
+            set(req.assistant) - {"role_name", "allow_network", "write_dirs"}
+        )
+        if assistant_unknown_fields:
+            raise HTTPException(
+                status_code=400,
+                detail=(
+                    "Unknown assistant fields: " + ", ".join(assistant_unknown_fields)
+                ),
+            )
+        if "allow_network" in req.assistant:
+            assistant_allow_network = req.assistant.get("allow_network")
+        if "write_dirs" in req.assistant:
+            assistant_write_dirs = req.assistant.get("write_dirs")
+        raw_role_name = req.assistant.get("role_name")
+        if isinstance(raw_role_name, str) and raw_role_name.strip():
+            assistant_role_name = raw_role_name
+
+    leader_role_name: str | None = None
+    if req.leader is not None:
+        raw_role_name = req.leader.get("role_name")
+        if isinstance(raw_role_name, str) and raw_role_name.strip():
+            leader_role_name = raw_role_name
+
+    timestamp_format: str | None = None
+    if req.event_log is not None:
+        raw_timestamp_format = req.event_log.get("timestamp_format")
+        if isinstance(raw_timestamp_format, str):
+            timestamp_format = raw_timestamp_format
+
+    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
+    model_params: object = MISSING
+    if req.model is not None:
+        raw_active_provider_id = req.model.get("active_provider_id")
+        if isinstance(raw_active_provider_id, str):
+            active_provider_id = raw_active_provider_id
+        raw_active_model = req.model.get("active_model")
+        if isinstance(raw_active_model, str):
+            active_model = raw_active_model
+        if "context_window_tokens" in req.model:
+            context_window_tokens = req.model.get("context_window_tokens")
+        if "input_image" in req.model:
+            input_image = req.model.get("input_image")
+        if "output_image" in req.model:
+            output_image = req.model.get("output_image")
+        if "structured_output" in req.model:
+            structured_output = req.model.get("structured_output")
+        if "timeout_ms" in req.model:
+            timeout_ms = req.model.get("timeout_ms")
+        if "retry_policy" in req.model:
+            retry_policy = req.model.get("retry_policy")
+        if "max_retries" in req.model:
+            max_retries = req.model.get("max_retries")
+        if "retry_initial_delay_seconds" in req.model:
+            retry_initial_delay_seconds = req.model.get("retry_initial_delay_seconds")
+        if "retry_max_delay_seconds" in req.model:
+            retry_max_delay_seconds = req.model.get("retry_max_delay_seconds")
+        if "retry_backoff_cap_retries" in req.model:
+            retry_backoff_cap_retries = req.model.get("retry_backoff_cap_retries")
+        if "auto_compact_token_limit" in req.model:
+            auto_compact_token_limit = req.model.get("auto_compact_token_limit")
+        if "params" in req.model:
+            model_params = req.model.get("params")
+
+    try:
+        resolved = resolve_settings_update(
+            current,
+            working_dir=req.working_dir,
+            assistant_role_name=assistant_role_name,
+            assistant_allow_network=assistant_allow_network,
+            assistant_write_dirs=assistant_write_dirs,
+            leader_role_name=leader_role_name,
+            active_provider_id=active_provider_id,
+            active_model=active_model,
+            context_window_tokens=context_window_tokens,
+            input_image=input_image,
+            output_image=output_image,
+            structured_output=structured_output,
+            max_retries=max_retries,
+            retry_policy=retry_policy,
+            timeout_ms=timeout_ms,
+            retry_initial_delay_seconds=retry_initial_delay_seconds,
+            retry_max_delay_seconds=retry_max_delay_seconds,
+            retry_backoff_cap_retries=retry_backoff_cap_retries,
+            auto_compact_token_limit=auto_compact_token_limit,
+            model_params=model_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

@@ -0,0 +1,310 @@
+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,
+    duplicate_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}/duplicate")
+async def duplicate_workflow_route(tab_id: str) -> dict[str, object]:
+    duplicated, error = duplicate_tab(tab_id=tab_id)
+    if error is not None or duplicated is None:
+        raise HTTPException(
+            status_code=404 if error and error.endswith("not found") else 400,
+            detail=error or "Failed to duplicate workflow",
+        )
+    return serialize_tab_summary(duplicated)
+
+
+@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

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