flowent 0.0.0 → 0.0.4

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

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import uuid
+from typing import Literal
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from flowent.assistant_commands import (
+    AssistantCommandError,
+    execute_assistant_command_input,
+)
+from flowent.image_assets import require_image_asset
+from flowent.models import (
+    Message,
+    content_parts_to_text,
+    has_image_parts,
+    parse_content_parts_payload,
+)
+from flowent.models import TextPart as ModelTextPart
+from flowent.providers.errors import LLMProviderError
+from flowent.registry import registry
+
+router = APIRouter()
+
+
+def _get_assistant():
+    return registry.get_assistant()
+
+
+@router.get("/api/assistant")
+async def get_assistant() -> dict:
+    assistant = _get_assistant()
+    if assistant is None:
+        raise HTTPException(status_code=404, detail="Assistant not found")
+    return {
+        "id": assistant.uuid,
+        "name": assistant.config.name,
+        "role_name": assistant.config.role_name,
+        "state": assistant.state.value,
+        "connections": assistant.get_connections_snapshot(),
+    }
+
+
+class AssistantMessageRequest(BaseModel):
+    content: str | None = None
+    parts: list[AssistantMessagePart] | None = None
+
+
+class AssistantMessagePart(BaseModel):
+    type: Literal["text", "image"]
+    text: str | None = None
+    asset_id: str | None = None
+    mime_type: str | None = None
+    width: int | None = None
+    height: int | None = None
+    alt: str | None = None
+
+
+AssistantMessageRequest.model_rebuild()
+
+
+class AssistantRetryResponse(BaseModel):
+    status: Literal["retried"]
+    message_id: str
+
+
+def _parse_request_parts(req: AssistantMessageRequest):
+    if req.parts:
+        parts = parse_content_parts_payload(
+            [part.model_dump(exclude_none=True) for part in req.parts]
+        )
+    elif isinstance(req.content, str):
+        parts = [ModelTextPart(text=req.content)]
+    else:
+        parts = []
+    if not parts:
+        raise HTTPException(status_code=400, detail="Assistant message cannot be empty")
+    if not has_image_parts(parts) and not content_parts_to_text(parts).strip():
+        raise HTTPException(status_code=400, detail="Assistant message cannot be empty")
+    for part in parts:
+        asset_id = getattr(part, "asset_id", None)
+        if isinstance(asset_id, str):
+            require_image_asset(asset_id)
+    return parts
+
+
+@router.post("/api/assistant/message")
+async def send_assistant_message(req: AssistantMessageRequest) -> dict:
+    assistant = _get_assistant()
+    if assistant is None:
+        raise HTTPException(status_code=404, detail="Assistant not found")
+
+    try:
+        parts = _parse_request_parts(req)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    if has_image_parts(parts) and not assistant.supports_input_image():
+        raise HTTPException(
+            status_code=409,
+            detail="Assistant current model does not support `input_image`.",
+        )
+
+    command_input = (
+        parts[0].text
+        if len(parts) == 1 and isinstance(parts[0], ModelTextPart)
+        else None
+    )
+
+    try:
+        executed_command = (
+            execute_assistant_command_input(assistant, command_input)
+            if isinstance(command_input, str)
+            else None
+        )
+    except AssistantCommandError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except (RuntimeError, TimeoutError, LLMProviderError) as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+    if executed_command is not None:
+        return {
+            "status": "command_executed",
+            "command_name": executed_command.command_name,
+        }
+
+    message_id = str(uuid.uuid4())
+    msg = Message(
+        from_id="human",
+        to_id=assistant.uuid,
+        parts=parts,
+        message_id=message_id,
+    )
+    assistant.enqueue_message(msg)
+    return {"status": "sent", "message_id": message_id}
+
+
+@router.post(
+    "/api/assistant/messages/{message_id}/retry",
+    response_model=AssistantRetryResponse,
+)
+async def retry_assistant_message(message_id: str) -> AssistantRetryResponse:
+    assistant = _get_assistant()
+    if assistant is None:
+        raise HTTPException(status_code=404, detail="Assistant not found")
+
+    try:
+        retried_message_id = assistant.retry_human_message(message_id=message_id)
+    except LookupError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except (RuntimeError, TimeoutError, ValueError) as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+    return AssistantRetryResponse(status="retried", message_id=retried_message_id)

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

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, File, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+
+from flowent.image_assets import create_image_asset, get_image_asset
+
+router = APIRouter()
+image_upload_file = File(...)
+
+
+@router.post("/api/image-assets")
+async def upload_image_asset(
+    file: UploadFile = image_upload_file,
+) -> dict[str, object]:
+    try:
+        data = await file.read()
+        asset = create_image_asset(
+            data,
+            mime_type=file.content_type,
+            original_name=file.filename,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return asset.serialize()
+
+
+@router.get("/api/image-assets/{asset_id}")
+async def get_uploaded_image_asset(asset_id: str) -> FileResponse:
+    asset = get_image_asset(asset_id)
+    if asset is None:
+        raise HTTPException(status_code=404, detail="Image asset not found")
+    return FileResponse(asset.file_path, media_type=asset.mime_type)

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

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from flowent.mcp_service import MCPError, mcp_service
+
+router = APIRouter()
+
+
+class MCPServerMutationRequest(BaseModel):
+    name: str
+    transport: str
+    enabled: bool = True
+    required: bool = False
+    startup_timeout_sec: int = 10
+    tool_timeout_sec: int = 30
+    enabled_tools: list[str] = []
+    disabled_tools: list[str] = []
+    scopes: list[str] = []
+    oauth_resource: str = ""
+    launcher: str = ""
+    command: str = ""
+    args: list[str] = []
+    env: dict[str, str] = {}
+    env_vars: list[str] = []
+    cwd: str = ""
+    url: str = ""
+    bearer_token_env_var: str = ""
+    http_headers: dict[str, str] = {}
+    env_http_headers: list[str] = []
+
+
+class MCPPromptPreviewRequest(BaseModel):
+    name: str
+    arguments: dict[str, object] = {}
+
+
+@router.get("/api/mcp")
+async def get_mcp_state() -> dict[str, object]:
+    return {"servers": mcp_service.list_server_payloads()}
+
+
+@router.post("/api/mcp/refresh")
+async def refresh_all_mcp_servers() -> dict[str, object]:
+    return {"servers": mcp_service.refresh_all()}
+
+
+@router.post("/api/mcp/servers")
+async def create_mcp_server(req: MCPServerMutationRequest) -> dict[str, object]:
+    try:
+        snapshot = mcp_service.create_or_update_server(
+            current_name=None,
+            config_data=req.model_dump(),
+        )
+    except MCPError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"snapshot": snapshot}
+
+
+@router.patch("/api/mcp/servers/{server_name}")
+async def update_mcp_server(
+    server_name: str,
+    req: MCPServerMutationRequest,
+) -> dict[str, object]:
+    try:
+        snapshot = mcp_service.create_or_update_server(
+            current_name=server_name,
+            config_data=req.model_dump(),
+        )
+    except MCPError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"snapshot": snapshot}
+
+
+@router.delete("/api/mcp/servers/{server_name}")
+async def delete_mcp_server(server_name: str) -> dict[str, object]:
+    try:
+        mcp_service.delete_server(server_name)
+    except MCPError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    return {"status": "deleted", "server_name": server_name}
+
+
+@router.post("/api/mcp/servers/{server_name}/refresh")
+async def refresh_mcp_server(server_name: str) -> dict[str, object]:
+    try:
+        snapshot = mcp_service.refresh_server(server_name)
+    except MCPError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"snapshot": snapshot}
+
+
+@router.post("/api/mcp/servers/{server_name}/login")
+async def login_mcp_server(server_name: str) -> dict[str, object]:
+    try:
+        snapshot = mcp_service.login_server(server_name)
+    except MCPError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"snapshot": snapshot}
+
+
+@router.post("/api/mcp/servers/{server_name}/logout")
+async def logout_mcp_server(server_name: str) -> dict[str, object]:
+    try:
+        snapshot = mcp_service.logout_server(server_name)
+    except MCPError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"snapshot": snapshot}
+
+
+@router.post("/api/mcp/servers/{server_name}/prompt-preview")
+async def preview_mcp_prompt(
+    server_name: str,
+    req: MCPPromptPreviewRequest,
+) -> dict[str, object]:
+    try:
+        preview = mcp_service.preview_server_prompt(
+            server_name=server_name,
+            name=req.name,
+            arguments=req.arguments,
+        )
+    except MCPError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"preview": preview}

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

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/health")
+async def health_check() -> dict:
+    return {"status": "healthy"}
+
+
+@router.get("/api/meta")
+async def get_meta() -> dict:
+    from flowent._version import __version__
+    from flowent.providers.registry import ProviderType
+
+    return {
+        "provider_types": [pt.value for pt in ProviderType],
+        "version": __version__,
+    }
+
+
+@router.get("/api/tools")
+async def list_tools() -> dict:
+    from flowent.tools import list_agent_visible_tool_descriptors
+
+    return {"tools": list_agent_visible_tool_descriptors()}

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

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from flowent.graph_service import is_tab_leader, list_node_connection_ids
+from flowent.registry import registry
+from flowent.settings import (
+    find_provider,
+    find_role,
+    get_settings,
+    resolve_model_info,
+)
+from flowent.tools import MINIMUM_TOOLS
+from flowent.workspace_store import workspace_store
+
+router = APIRouter()
+
+
+class DispatchNodeMessagePart(BaseModel):
+    type: Literal["text", "image"]
+    text: str | None = None
+    asset_id: str | None = None
+    mime_type: str | None = None
+    width: int | None = None
+    height: int | None = None
+    alt: str | None = None
+
+
+class DispatchNodeMessageRequest(BaseModel):
+    content: str | None = None
+    parts: list[DispatchNodeMessagePart] | None = None
+    from_id: str = "human"
+
+
+DispatchNodeMessageRequest.model_rebuild()
+
+
+def _parse_dispatch_parts(req: DispatchNodeMessageRequest):
+    from flowent.image_assets import require_image_asset
+    from flowent.models import TextPart as ModelTextPart
+    from flowent.models import (
+        content_parts_to_text,
+        has_image_parts,
+        parse_content_parts_payload,
+    )
+
+    if req.parts:
+        parts = parse_content_parts_payload(
+            [part.model_dump(exclude_none=True) for part in req.parts]
+        )
+    elif isinstance(req.content, str):
+        parts = [ModelTextPart(text=req.content)]
+    else:
+        parts = []
+
+    if not parts:
+        raise HTTPException(status_code=400, detail="Node message cannot be empty")
+    if not has_image_parts(parts) and not content_parts_to_text(parts).strip():
+        raise HTTPException(status_code=400, detail="Node message cannot be empty")
+
+    for part in parts:
+        asset_id = getattr(part, "asset_id", None)
+        if isinstance(asset_id, str):
+            require_image_asset(asset_id)
+    return parts
+
+
+def _serialize_model_capabilities(role_name: str | None) -> dict[str, bool] | None:
+    settings = get_settings()
+    provider_id = settings.model.active_provider_id
+    model_id = settings.model.active_model
+    use_system_model_overrides = True
+    role_cfg = find_role(settings, role_name) if role_name else None
+    if (
+        role_cfg is not None
+        and role_cfg.model is not None
+        and role_cfg.model.provider_id
+        and role_cfg.model.model
+    ):
+        provider_id = role_cfg.model.provider_id
+        model_id = role_cfg.model.model
+        use_system_model_overrides = False
+    if not provider_id or not model_id:
+        return None
+    provider = find_provider(settings, provider_id)
+    if provider is None:
+        return None
+    model_info = resolve_model_info(
+        provider=provider,
+        model_id=model_id,
+        input_image=settings.model.input_image if use_system_model_overrides else None,
+        output_image=(
+            settings.model.output_image if use_system_model_overrides else None
+        ),
+        context_window_tokens=(
+            settings.model.context_window_tokens if use_system_model_overrides else None
+        ),
+    )
+    return {
+        "input_image": model_info.capabilities.input_image,
+        "output_image": model_info.capabilities.output_image,
+    }
+
+
+@router.get("/api/nodes")
+async def list_nodes() -> dict:
+    nodes_by_id: dict[str, dict[str, object]] = {}
+
+    assistant = registry.get_assistant()
+    if assistant is not None:
+        nodes_by_id[assistant.uuid] = {
+            "id": assistant.uuid,
+            "node_type": assistant.config.node_type.value,
+            "workflow_id": assistant.config.tab_id,
+            "role_name": assistant.config.role_name,
+            "state": assistant.state.value,
+            "connections": assistant.get_connections_snapshot(),
+            "name": assistant.config.name,
+            "is_leader": False,
+            "todos": [t.serialize() for t in assistant.todos],
+            "capabilities": _serialize_model_capabilities(assistant.config.role_name),
+            "position": None,
+        }
+
+    for record in workspace_store.list_node_records():
+        live = registry.get(record.id)
+        nodes_by_id[record.id] = {
+            "id": record.id,
+            "node_type": record.config.node_type.value,
+            "workflow_id": record.config.tab_id,
+            "role_name": record.config.role_name,
+            "is_leader": is_tab_leader(node_id=record.id, tab_id=record.config.tab_id),
+            "state": (live.state if live is not None else record.state).value,
+            "connections": (
+                list_node_connection_ids(
+                    tab_id=record.config.tab_id,
+                    node_id=record.id,
+                )
+                if record.config.tab_id
+                else []
+            ),
+            "name": record.config.name,
+            "todos": [
+                todo.serialize()
+                for todo in (
+                    live.get_todos_snapshot() if live is not None else record.todos
+                )
+            ],
+            "capabilities": _serialize_model_capabilities(record.config.role_name),
+            "position": record.position.serialize()
+            if record.position is not None
+            else None,
+        }
+
+    for node in registry.get_all():
+        if node.uuid in nodes_by_id:
+            continue
+        nodes_by_id[node.uuid] = {
+            "id": node.uuid,
+            "node_type": node.config.node_type.value,
+            "workflow_id": node.config.tab_id,
+            "role_name": node.config.role_name,
+            "is_leader": is_tab_leader(node_id=node.uuid, tab_id=node.config.tab_id),
+            "state": node.state.value,
+            "connections": (
+                list_node_connection_ids(
+                    tab_id=node.config.tab_id,
+                    node_id=node.uuid,
+                )
+                if node.config.tab_id
+                else node.get_connections_snapshot()
+            ),
+            "name": node.config.name,
+            "todos": [t.serialize() for t in node.todos],
+            "capabilities": _serialize_model_capabilities(node.config.role_name),
+            "position": None,
+        }
+
+    return {
+        "nodes": list(nodes_by_id.values()),
+    }
+
+
+@router.get("/api/nodes/{node_id}")
+async def get_node(node_id: str) -> dict:
+    node = registry.get(node_id)
+    record = workspace_store.get_node_record(node_id)
+
+    if node is None and record is None:
+        raise HTTPException(status_code=404, detail="Node not found")
+
+    if node is not None:
+        record_id = node.uuid
+        record_state = node.state
+        target_config = node.config
+    else:
+        assert record is not None
+        record_id = record.id
+        record_state = record.state
+        target_config = record.config
+    history = (
+        node.get_history_snapshot()
+        if node is not None
+        else (record.history if record is not None else [])
+    )
+    todos = (
+        node.get_todos_snapshot()
+        if node is not None
+        else (record.todos if record is not None else [])
+    )
+
+    return {
+        "id": record_id,
+        "node_type": target_config.node_type.value,
+        "workflow_id": target_config.tab_id,
+        "role_name": target_config.role_name,
+        "is_leader": is_tab_leader(node_id=record_id, tab_id=target_config.tab_id),
+        "state": record_state.value,
+        "contacts": node.get_contact_ids_snapshot() if node is not None else [],
+        "connections": (
+            list_node_connection_ids(
+                tab_id=target_config.tab_id,
+                node_id=record_id,
+            )
+            if target_config.tab_id
+            else (node.get_connections_snapshot() if node is not None else [])
+        ),
+        "name": target_config.name,
+        "todos": [t.serialize() for t in todos],
+        "capabilities": _serialize_model_capabilities(target_config.role_name),
+        "tools": sorted(set(target_config.tools) | set(MINIMUM_TOOLS)),
+        "write_dirs": list(target_config.write_dirs),
+        "allow_network": target_config.allow_network,
+        "position": record.position.serialize()
+        if record is not None and record.position is not None
+        else None,
+        "history": [entry.serialize() for entry in history],
+    }
+
+
+@router.post("/api/nodes/{node_id}/terminate")
+async def terminate_node(node_id: str) -> dict:
+    node = registry.get(node_id)
+    if node is None:
+        raise HTTPException(status_code=404, detail="Node not found")
+
+    from flowent.models import NodeType
+
+    if node.config.node_type == NodeType.ASSISTANT:
+        raise HTTPException(status_code=400, detail="Cannot terminate assistant")
+    if is_tab_leader(node_id=node.uuid, tab_id=node.config.tab_id):
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot terminate a workflow Leader directly",
+        )
+
+    node.request_termination("user_requested")
+    return {"status": "terminating"}
+
+
+@router.post("/api/nodes/{node_id}/interrupt")
+async def interrupt_node(node_id: str) -> dict:
+    node = registry.get(node_id)
+    if node is None:
+        raise HTTPException(status_code=404, detail="Node not found")
+    if not node.request_interrupt():
+        return {"status": "ignored"}
+    return {"status": "interrupting"}
+
+
+@router.post("/api/nodes/{node_id}/messages/{message_id}/retry")
+async def retry_node_message(node_id: str, message_id: str) -> dict:
+    node = registry.get(node_id)
+    if node is None:
+        raise HTTPException(status_code=404, detail="Node not found")
+    from flowent.models import NodeType
+
+    if node.config.node_type == NodeType.ASSISTANT:
+        raise HTTPException(
+            status_code=400,
+            detail="Use /api/assistant/messages/{message_id}/retry for Assistant retry",
+        )
+    if not is_tab_leader(node_id=node.uuid, tab_id=node.config.tab_id):
+        raise HTTPException(
+            status_code=400,
+            detail="Only a Workflow Leader can retry chat history",
+        )
+    try:
+        retried_message_id = node.retry_received_message(message_id=message_id)
+    except LookupError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except (RuntimeError, TimeoutError, ValueError) as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    return {"status": "retried", "message_id": retried_message_id}
+
+
+@router.post("/api/nodes/{node_id}/clear-chat")
+async def clear_node_chat(node_id: str) -> dict:
+    from flowent.models import NodeType
+
+    node = registry.get(node_id)
+    if node is None:
+        raise HTTPException(status_code=404, detail="Node not found")
+    if node.config.node_type != NodeType.ASSISTANT:
+        raise HTTPException(status_code=400, detail="Can only clear assistant chat")
+
+    try:
+        node.clear_chat_history()
+    except RuntimeError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    except TimeoutError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+    return {"status": "cleared"}
+
+
+@router.post("/api/nodes/{node_id}/messages")
+async def dispatch_node_message(node_id: str, req: DispatchNodeMessageRequest) -> dict:
+    from flowent.graph_service import dispatch_node_message
+    from flowent.models import NodeType, content_parts_to_text, has_image_parts
+
+    node = registry.get(node_id)
+    if node is None:
+        raise HTTPException(status_code=404, detail="Node not found")
+
+    if req.from_id != "human":
+        raise HTTPException(
+            status_code=400,
+            detail="Web UI node messages must originate from `human`",
+        )
+
+    if node.config.node_type == NodeType.ASSISTANT:
+        raise HTTPException(
+            status_code=400,
+            detail="Use /api/assistant/message for Assistant input",
+        )
+    if not is_tab_leader(node_id=node.uuid, tab_id=node.config.tab_id):
+        raise HTTPException(
+            status_code=400,
+            detail="Human input can only target Assistant or a Workflow Leader",
+        )
+
+    try:
+        parts = _parse_dispatch_parts(req)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    if has_image_parts(parts) and not node.supports_input_image():
+        raise HTTPException(
+            status_code=409,
+            detail="Current model does not support `input_image`.",
+        )
+
+    error, message_id = dispatch_node_message(
+        node_id=node_id,
+        content=content_parts_to_text(parts),
+        parts=parts,
+        from_id="human",
+    )
+    if error is not None:
+        raise HTTPException(status_code=400, detail=error)
+    return {"status": "sent", "message_id": message_id}