flowent 0.0.6 → 0.0.10

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

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

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

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-import uuid
-from typing import Literal
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-
-from flowent.assistant_commands import (
-    ConversationCommandError,
-    execute_conversation_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_conversation_command_input(assistant, command_input)
-            if isinstance(command_input, str)
-            else None
-        )
-    except ConversationCommandError 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

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

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

@@ -1,28 +0,0 @@
-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()}