flowent 0.0.12 → 0.1.0

package/backend/src/flowent/main.py

@@ -2,6 +2,7 @@ import json
 import logging
 import os
 from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Literal
 from uuid import uuid4
@@ -13,6 +14,7 @@ from pydantic import BaseModel, ConfigDict
 
 from flowent._version import __version__
 from flowent.agent import run_agent_stream
+from flowent.channels import TelegramBotManager, TelegramTransport
 from flowent.context import runtime_context_messages
 from flowent.llm import (
     ChatMessage,
@@ -23,13 +25,24 @@ from flowent.llm import (
     list_provider_models,
 )
 from flowent.logging import TRACE_LEVEL, ensure_logging_configured
+from flowent.mcp import McpManager, McpTransport
+from flowent.mcp_import import McpImportDiscovery, discover_imported_mcp_servers
 from flowent.sandbox import ensure_sandbox_available
+from flowent.skills import (
+    discover_skills,
+    explicit_skill_messages,
+    update_skill_enabled,
+)
 from flowent.storage import (
     StateStore,
+    StoredMcpServer,
     StoredMessage,
     StoredProvider,
     StoredSettings,
+    StoredSkill,
     StoredState,
+    StoredTelegramBot,
+    StoredTelegramSession,
     StoredToolItem,
 )
 
@@ -77,6 +90,24 @@ class AboutResponse(BaseModel):
     version: str
 
 
+class TelegramSessionApproveRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    chat_id: str
+
+
+class SkillSettingsRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: bool
+
+
+class McpImportRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    duplicate_action: Literal["replace", "skip"] = "skip"
+
+
 def stream_event(event: str, data: dict[str, object]) -> str:
     return f"event: {event}\ndata: {json.dumps(data)}\n\n"
 
@@ -192,24 +223,137 @@ def create_app(
     *,
     serve_frontend: bool = True,
     chat_completion: CompletionCallable | None = None,
+    mcp_transport: McpTransport | None = None,
+    telegram_transport: TelegramTransport | None = None,
 ) -> FastAPI:
     ensure_logging_configured()
     ensure_sandbox_available()
 
-    app = FastAPI(title="Flowent")
     store = StateStore()
+    mcp_manager = McpManager(store=store, transport=mcp_transport)
+    telegram_bot_manager: TelegramBotManager | None = None
 
     static_dir = frontend_static_directory().resolve(strict=False)
     logger.debug("Flowent app created serve_frontend=%s", serve_frontend)
     logger.info("Static directory: %s", static_dir)
 
+    async def run_workspace_turn(content: str) -> StoredMessage:
+        state = store.read_state()
+        connection = selected_connection(state)
+        cwd = Path.cwd()
+        user_message = StoredMessage(
+            author="user",
+            content=content,
+            id=str(uuid4()),
+        )
+        next_messages = [*state.messages, user_message]
+        store.save_messages(next_messages)
+        chat_messages = workspace_chat_messages(
+            next_messages,
+            store.read_compacted_context(),
+        )
+        skill_messages = explicit_skill_messages(cwd, store, content)
+        request_messages = [
+            message.model_dump()
+            for message in [
+                *runtime_context_messages(cwd),
+                *skill_messages,
+                *chat_messages,
+            ]
+        ]
+        assistant_content = ""
+        assistant_thinking = ""
+        assistant_tools: dict[str, StoredToolItem] = {}
+        assistant_id = str(uuid4())
+
+        async for event in run_agent_stream(
+            completion=chat_completion,
+            connection=connection,
+            cwd=cwd,
+            extra_tool_runner=mcp_manager.run_tool,
+            extra_tool_specs=mcp_manager.tool_specs(),
+            extra_tool_title=mcp_manager.tool_title,
+            messages=request_messages,
+        ):
+            if event.event == "delta":
+                assistant_content += str(event.data.get("content") or "")
+            if event.event == "thinking_delta":
+                assistant_thinking += str(event.data.get("content") or "")
+            if event.event == "tool_start":
+                tool = event.data.get("tool")
+                if isinstance(tool, dict) and isinstance(tool.get("id"), str):
+                    assistant_tools[tool["id"]] = StoredToolItem.model_validate(tool)
+            if event.event in {"tool_done", "tool_error"}:
+                tool_id = event.data.get("id")
+                if isinstance(tool_id, str) and tool_id in assistant_tools:
+                    assistant_tools[tool_id] = StoredToolItem.model_validate(
+                        {
+                            **assistant_tools[tool_id].model_dump(exclude_none=True),
+                            **event.data,
+                        }
+                    )
+            if event.event == "done":
+                message = event.data.get("message")
+                if isinstance(message, dict):
+                    assistant_id = str(message.get("id") or assistant_id)
+                    assistant_content = str(message.get("content") or assistant_content)
+                    assistant_thinking = str(
+                        message.get("thinking") or assistant_thinking
+                    )
+
+        assistant_message = StoredMessage(
+            author="assistant",
+            content=assistant_content,
+            id=assistant_id,
+            thinking=assistant_thinking,
+            tools=list(assistant_tools.values()),
+        )
+        store.save_messages([*next_messages, assistant_message])
+        return assistant_message
+
+    async def workspace_reply_text(content: str) -> str:
+        return (await run_workspace_turn(content)).content
+
+    telegram_bot_manager = TelegramBotManager(
+        message_handler=workspace_reply_text,
+        store=store,
+        telegram_transport=telegram_transport,
+    )
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+        app.state.mcp_manager = mcp_manager
+        app.state.telegram_bot_manager = telegram_bot_manager
+        await mcp_manager.start_enabled()
+        if telegram_bot_manager is not None:
+            await telegram_bot_manager.start_enabled()
+        try:
+            yield
+        finally:
+            if telegram_bot_manager is not None:
+                await telegram_bot_manager.stop_all()
+            await mcp_manager.stop_all()
+
+    app = FastAPI(title="Flowent", lifespan=lifespan)
+    app.state.mcp_manager = mcp_manager
+    app.state.telegram_bot_manager = telegram_bot_manager
+
     @app.get("/api/health")
     async def health() -> dict[str, str]:
         return {"status": "ok"}
 
     @app.get("/api/state")
     async def app_state() -> StoredState:
-        return store.read_state()
+        state = store.read_state()
+        update: dict[str, object] = {
+            "mcp_servers": mcp_manager.servers_with_status(state.mcp_servers),
+            "skills": discover_skills(Path.cwd(), store),
+        }
+        if telegram_bot_manager is not None:
+            update["telegram_bot"] = telegram_bot_manager.bot_with_status(
+                state.telegram_bot
+            )
+        return state.model_copy(update=update)
 
     @app.get("/api/about")
     async def about() -> AboutResponse:
@@ -219,6 +363,78 @@ def create_app(
     async def save_provider(provider: StoredProvider) -> StoredProvider:
         return store.save_provider(provider)
 
+    @app.put("/api/mcp/servers")
+    async def save_mcp_server(server: StoredMcpServer) -> StoredMcpServer:
+        saved_server = store.save_mcp_server(server)
+        return await mcp_manager.sync_server(saved_server)
+
+    @app.get("/api/mcp/import/preview")
+    async def preview_mcp_import() -> McpImportDiscovery:
+        return discover_imported_mcp_servers(Path.cwd())
+
+    @app.post("/api/mcp/import")
+    async def import_mcp_servers(request: McpImportRequest) -> list[StoredMcpServer]:
+        imported_servers = discover_imported_mcp_servers(Path.cwd()).servers
+        existing_servers = {server.id for server in store.read_mcp_servers()}
+        for server in imported_servers:
+            if request.duplicate_action == "skip" and server.id in existing_servers:
+                continue
+            if request.duplicate_action == "replace" and server.id in existing_servers:
+                await mcp_manager.delete_server(server.id)
+            store.save_mcp_server(server)
+            existing_servers.add(server.id)
+        return mcp_manager.servers_with_status(store.read_mcp_servers())
+
+    @app.delete("/api/mcp/servers/{server_id}")
+    async def delete_mcp_server(server_id: str) -> dict[str, bool]:
+        await mcp_manager.delete_server(server_id)
+        return {"ok": True}
+
+    @app.post("/api/mcp/servers/{server_id}/reconnect")
+    async def reconnect_mcp_server(server_id: str) -> StoredMcpServer:
+        try:
+            return await mcp_manager.reconnect_server(server_id)
+        except KeyError as error:
+            raise HTTPException(status_code=404, detail="Server not found.") from error
+
+    @app.post("/api/mcp/reload")
+    async def reload_mcp_servers() -> list[StoredMcpServer]:
+        return await mcp_manager.reload()
+
+    @app.post("/api/skills/reload")
+    async def reload_skills() -> list[StoredSkill]:
+        return discover_skills(Path.cwd(), store)
+
+    @app.put("/api/skills/{skill_id:path}")
+    async def save_skill_settings(
+        skill_id: str,
+        request: SkillSettingsRequest,
+    ) -> StoredSkill:
+        try:
+            return update_skill_enabled(Path.cwd(), store, skill_id, request.enabled)
+        except KeyError as error:
+            raise HTTPException(status_code=404, detail="Skill not found.") from error
+
+    @app.put("/api/telegram-bot")
+    async def save_telegram_bot(telegram_bot: StoredTelegramBot) -> StoredTelegramBot:
+        saved_bot = store.save_telegram_bot(telegram_bot)
+        if telegram_bot_manager is not None:
+            await telegram_bot_manager.sync_bot(saved_bot)
+            return telegram_bot_manager.bot_with_status(saved_bot)
+        return saved_bot
+
+    @app.post("/api/telegram-bot/approve")
+    async def approve_telegram_session(
+        request: TelegramSessionApproveRequest,
+    ) -> StoredTelegramSession:
+        try:
+            return store.approve_telegram_session(request.chat_id)
+        except KeyError as error:
+            raise HTTPException(
+                status_code=404,
+                detail="Conversation not found.",
+            ) from error
+
     @app.post("/api/providers/models")
     async def provider_models(request: ProviderModelsRequest) -> ProviderModelsResponse:
         return ProviderModelsResponse(
@@ -304,7 +520,11 @@ def create_app(
         )
         request_messages = [
             message.model_dump()
-            for message in [*runtime_context_messages(cwd), *chat_messages]
+            for message in [
+                *runtime_context_messages(cwd),
+                *explicit_skill_messages(cwd, store, request.content),
+                *chat_messages,
+            ]
         ]
 
         async def response_stream() -> AsyncIterator[str]:
@@ -314,6 +534,9 @@ def create_app(
                     completion=chat_completion,
                     connection=connection,
                     cwd=cwd,
+                    extra_tool_runner=mcp_manager.run_tool,
+                    extra_tool_specs=mcp_manager.tool_specs(),
+                    extra_tool_title=mcp_manager.tool_title,
                     messages=request_messages,
                 ):
                     if event.event == "tool_start":