flowent 0.0.13 → 0.1.1

package/backend/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowent"
-version = "0.0.13"
+version = "0.1.1"
 description = "A workflow orchestration platform for multi-agent collaboration."
 readme = "README.md"
 authors = [
@@ -11,6 +11,7 @@ license = "Apache-2.0"
 dependencies = [
     "fastapi[standard]>=0.136.1",
     "litellm>=1.84.0",
+    "mcp>=1.24.0",
     "uvicorn>=0.46.0",
 ]
 

package/backend/src/flowent/agent.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import AsyncIterator, Callable, Mapping, Sequence
+from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 from uuid import uuid4
@@ -20,6 +20,7 @@ from flowent.llm import (
 from flowent.logging import TRACE_LEVEL
 from flowent.tools import (
     ToolContext,
+    ToolResult,
     new_tool_item,
     parse_tool_arguments,
     run_tool,
@@ -104,6 +105,10 @@ async def run_agent_stream(
     connection: ProviderConnection,
     cwd: Path,
     messages: Sequence[Mapping[str, object]],
+    extra_tool_runner: Callable[[str, dict[str, object]], Awaitable[ToolResult | None]]
+    | None = None,
+    extra_tool_specs: Sequence[Mapping[str, object]] | None = None,
+    extra_tool_title: Callable[[str], str | None] | None = None,
     web_searcher: Callable[[str], Sequence[dict[str, str]]] | None = None,
 ) -> AsyncIterator[AgentStreamEvent]:
     conversation: list[Mapping[str, object]] = [
@@ -132,7 +137,10 @@ async def run_agent_stream(
         pending: dict[int, PendingToolCall] = {}
 
         async for chunk in stream_chat_chunks(
-            connection, conversation, completion=completion, tools=tool_specs()
+            connection,
+            conversation,
+            completion=completion,
+            tools=[*tool_specs(), *list(extra_tool_specs or [])],
         ):
             reasoning = chunk_delta_reasoning(chunk)
             if reasoning:
@@ -221,16 +229,29 @@ async def run_agent_stream(
                     },
                 )
             else:
-                tool_item = new_tool_item(tool_call.name, arguments)
+                tool_item = new_tool_item(
+                    tool_call.name,
+                    arguments,
+                    extra_tool_title(tool_call.name) if extra_tool_title else None,
+                )
                 logger.debug(
                     "Tool call started name=%s id=%s", tool_call.name, tool_item["id"]
                 )
                 logger.log(TRACE_LEVEL, "Tool start item=%r", tool_item)
                 yield AgentStreamEvent(event="tool_start", data={"tool": tool_item})
-                result = run_tool(
-                    tool_call.name,
-                    arguments,
-                    ToolContext(cwd=cwd, web_searcher=web_searcher),
+                extra_result = (
+                    await extra_tool_runner(tool_call.name, arguments)
+                    if extra_tool_runner is not None
+                    else None
+                )
+                result = (
+                    extra_result
+                    if isinstance(extra_result, ToolResult)
+                    else run_tool(
+                        tool_call.name,
+                        arguments,
+                        ToolContext(cwd=cwd, web_searcher=web_searcher),
+                    )
                 )
                 result_content = result.content
                 logger.debug(

package/backend/src/flowent/main.py

@@ -25,12 +25,21 @@ 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,
@@ -87,6 +96,25 @@ class TelegramSessionApproveRequest(BaseModel):
     chat_id: str
 
 
+class SkillSettingsRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: bool
+
+
+class McpImportRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    server_id: str
+    source: Literal["claude_code", "codex"]
+
+
+class McpImportPreviewRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    source: Literal["claude_code", "codex"]
+
+
 def stream_event(event: str, data: dict[str, object]) -> str:
     return f"event: {event}\ndata: {json.dumps(data)}\n\n"
 
@@ -202,12 +230,14 @@ 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()
 
     store = StateStore()
+    mcp_manager = McpManager(store=store, transport=mcp_transport)
     telegram_bot_manager: TelegramBotManager | None = None
 
     static_dir = frontend_static_directory().resolve(strict=False)
@@ -229,9 +259,14 @@ def create_app(
             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), *chat_messages]
+            for message in [
+                *runtime_context_messages(cwd),
+                *skill_messages,
+                *chat_messages,
+            ]
         ]
         assistant_content = ""
         assistant_thinking = ""
@@ -242,6 +277,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 == "delta":
@@ -291,7 +329,9 @@ def create_app(
 
     @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:
@@ -299,8 +339,11 @@ def create_app(
         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]:
@@ -309,13 +352,15 @@ def create_app(
     @app.get("/api/state")
     async def app_state() -> StoredState:
         state = store.read_state()
-        if telegram_bot_manager is None:
-            return state
-        return state.model_copy(
-            update={
-                "telegram_bot": telegram_bot_manager.bot_with_status(state.telegram_bot)
-            }
-        )
+        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:
@@ -325,6 +370,63 @@ 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.post("/api/mcp/import/preview")
+    async def preview_mcp_import(
+        request: McpImportPreviewRequest,
+    ) -> McpImportDiscovery:
+        return discover_imported_mcp_servers(Path.cwd(), source=request.source)
+
+    @app.post("/api/mcp/import")
+    async def import_mcp_servers(request: McpImportRequest) -> list[StoredMcpServer]:
+        imported_servers = discover_imported_mcp_servers(
+            Path.cwd(),
+            source=request.source,
+        ).servers
+        existing_servers = {server.id for server in store.read_mcp_servers()}
+        for server in imported_servers:
+            if server.id != request.server_id:
+                continue
+            if server.id in existing_servers:
+                continue
+            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)
@@ -430,7 +532,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]:
@@ -440,6 +546,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":