flowent 0.1.0 → 0.1.2

package/backend/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowent"
-version = "0.1.0"
+version = "0.1.2"
 description = "A workflow orchestration platform for multi-agent collaboration."
 readme = "README.md"
 authors = [

package/backend/src/flowent/agent.py

@@ -23,7 +23,7 @@ from flowent.tools import (
     ToolResult,
     new_tool_item,
     parse_tool_arguments,
-    run_tool,
+    run_tool_async,
     tool_specs,
 )
 
@@ -109,6 +109,8 @@ async def run_agent_stream(
     | None = None,
     extra_tool_specs: Sequence[Mapping[str, object]] | None = None,
     extra_tool_title: Callable[[str], str | None] | None = None,
+    tool_runner: Callable[[str, dict[str, object], ToolContext], Awaitable[ToolResult]]
+    | None = None,
     web_searcher: Callable[[str], Sequence[dict[str, str]]] | None = None,
 ) -> AsyncIterator[AgentStreamEvent]:
     conversation: list[Mapping[str, object]] = [
@@ -244,15 +246,22 @@ async def run_agent_stream(
                     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 = extra_result if isinstance(extra_result, ToolResult) else None
+                if result is None:
+                    context = ToolContext(cwd=cwd, web_searcher=web_searcher)
+                    result = await (
+                        tool_runner(
+                            tool_call.name,
+                            arguments,
+                            context,
+                        )
+                        if tool_runner is not None
+                        else run_tool_async(
+                            tool_call.name,
+                            arguments,
+                            context,
+                        )
                     )
-                )
                 result_content = result.content
                 logger.debug(
                     "Tool call finished name=%s id=%s ok=%s",

package/backend/src/flowent/main.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import logging
 import os
@@ -105,13 +106,29 @@ class SkillSettingsRequest(BaseModel):
 class McpImportRequest(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    duplicate_action: Literal["replace", "skip"] = "skip"
+    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"
 
 
+def append_or_replace_message(
+    messages: list[StoredMessage], message: StoredMessage
+) -> list[StoredMessage]:
+    return [
+        *(current for current in messages if current.id != message.id),
+        message,
+    ]
+
+
 def frontend_static_directory() -> Path:
     configured_directory = os.environ.get("FLOWENT_STATIC_DIR")
     if configured_directory:
@@ -305,6 +322,7 @@ def create_app(
             author="assistant",
             content=assistant_content,
             id=assistant_id,
+            status="completed",
             thinking=assistant_thinking,
             tools=list(assistant_tools.values()),
         )
@@ -368,19 +386,24 @@ def create_app(
         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/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()).servers
+        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 request.duplicate_action == "skip" and server.id in existing_servers:
+            if server.id != request.server_id:
+                continue
+            if 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())
@@ -529,6 +552,30 @@ def create_app(
 
         async def response_stream() -> AsyncIterator[str]:
             assistant_tools: dict[str, StoredToolItem] = {}
+            assistant_message = StoredMessage(
+                author="assistant",
+                content="",
+                id=str(uuid4()),
+                status="running",
+            )
+            assistant_content = ""
+            assistant_thinking = ""
+
+            def persist_assistant(status: str = "running") -> None:
+                nonlocal next_messages, assistant_message
+                assistant_message = StoredMessage(
+                    author="assistant",
+                    content=assistant_content,
+                    id=assistant_message.id,
+                    status=status,
+                    thinking=assistant_thinking,
+                    tools=list(assistant_tools.values()),
+                )
+                next_messages = append_or_replace_message(
+                    next_messages, assistant_message
+                )
+                store.upsert_message(assistant_message)
+
             try:
                 async for event in run_agent_stream(
                     completion=chat_completion,
@@ -539,12 +586,20 @@ def create_app(
                     extra_tool_title=mcp_manager.tool_title,
                     messages=request_messages,
                 ):
+                    if event.event == "start":
+                        event_id = event.data.get("id")
+                        if isinstance(event_id, str):
+                            assistant_message = assistant_message.model_copy(
+                                update={"id": event_id}
+                            )
+                            persist_assistant()
                     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
                             )
+                            persist_assistant()
                     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:
@@ -556,6 +611,13 @@ def create_app(
                                     **event.data,
                                 }
                             )
+                            persist_assistant()
+                    if event.event == "delta":
+                        assistant_content += str(event.data.get("content") or "")
+                        persist_assistant()
+                    if event.event == "thinking_delta":
+                        assistant_thinking += str(event.data.get("content") or "")
+                        persist_assistant()
                     logger.log(
                         TRACE_LEVEL,
                         "Workspace stream event=%s data=%r",
@@ -565,19 +627,21 @@ def create_app(
                     if event.event == "done":
                         message = event.data.get("message")
                         if isinstance(message, dict):
-                            next_messages.append(
-                                StoredMessage(
-                                    author="assistant",
-                                    content=str(message.get("content") or ""),
-                                    id=str(message.get("id") or uuid4()),
-                                    thinking=str(message.get("thinking") or ""),
-                                    tools=list(assistant_tools.values()),
-                                )
+                            assistant_content = str(
+                                message.get("content") or assistant_content
+                            )
+                            assistant_thinking = str(
+                                message.get("thinking") or assistant_thinking
                             )
-                            store.save_messages(next_messages)
+                            persist_assistant("completed")
                     yield stream_event(event.event, event.data)
+            except asyncio.CancelledError:
+                logger.info("Workspace response interrupted")
+                persist_assistant("interrupted")
+                raise
             except Exception as error:
                 logger.exception("Workspace response failed")
+                persist_assistant("failed")
                 yield stream_event(
                     "error",
                     {"message": str(error) or "Message could not be sent."},

package/backend/src/flowent/mcp_import.py

@@ -33,21 +33,26 @@ class McpImportDiscovery(BaseModel):
 def discover_imported_mcp_servers(
     cwd: Path | None = None,
     home: Path | None = None,
+    source: McpImportSource | None = None,
 ) -> McpImportDiscovery:
     workspace = (cwd or Path.cwd()).resolve(strict=False)
     user_home = (home or Path.home()).resolve(strict=False)
     sources: list[McpImportSourceResult] = []
 
-    for path, source in candidate_mcp_config_files(workspace, user_home):
+    for path, config_source in candidate_mcp_config_files(
+        workspace,
+        user_home,
+        source,
+    ):
         if not path.is_file():
             continue
         try:
-            servers = parse_mcp_config_file(path, source, workspace)
+            servers = parse_mcp_config_file(path, config_source, workspace)
             sources.append(
                 McpImportSourceResult(
                     path=str(path.resolve(strict=False)),
                     servers=servers,
-                    source=source,
+                    source=config_source,
                 )
             )
         except Exception as error:
@@ -55,7 +60,7 @@ def discover_imported_mcp_servers(
                 McpImportSourceResult(
                     error=str(error),
                     path=str(path.resolve(strict=False)),
-                    source=source,
+                    source=config_source,
                 )
             )
 
@@ -70,16 +75,26 @@ def discover_imported_mcp_servers(
 def candidate_mcp_config_files(
     cwd: Path,
     home: Path,
+    source: McpImportSource | None = None,
 ) -> list[tuple[Path, McpImportSource]]:
-    candidates: list[tuple[Path, McpImportSource]] = [
-        (cwd / ".mcp.json", "claude_code"),
-        (cwd / ".claude" / "settings.local.json", "claude_code"),
-        (cwd / ".claude" / "settings.json", "claude_code"),
-        (home / ".claude.json", "claude_code"),
-        (home / ".claude" / "settings.json", "claude_code"),
-        (cwd / ".codex" / "config.toml", "codex"),
-        (home / ".codex" / "config.toml", "codex"),
-    ]
+    candidates: list[tuple[Path, McpImportSource]] = []
+    if source in (None, "claude_code"):
+        candidates.extend(
+            [
+                (cwd / ".mcp.json", "claude_code"),
+                (cwd / ".claude" / "settings.local.json", "claude_code"),
+                (cwd / ".claude" / "settings.json", "claude_code"),
+                (home / ".claude.json", "claude_code"),
+                (home / ".claude" / "settings.json", "claude_code"),
+            ]
+        )
+    if source in (None, "codex"):
+        candidates.extend(
+            [
+                (cwd / ".codex" / "config.toml", "codex"),
+                (home / ".codex" / "config.toml", "codex"),
+            ]
+        )
     seen: set[tuple[Path, McpImportSource]] = set()
     unique_candidates: list[tuple[Path, McpImportSource]] = []
     for path, source in candidates:

package/backend/src/flowent/sandbox.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
+import asyncio
 import ctypes
 import errno
 import os
 import shutil
+import signal
 import subprocess
 import tempfile
+from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
 from typing import BinaryIO
@@ -127,7 +130,7 @@ class SandboxRunner:
         self,
         *,
         cwd: Path | None = None,
-        timeout_seconds: int = 30,
+        timeout_seconds: float = 30,
         output_limit: int = 20000,
     ) -> None:
         self.cwd = (cwd or Path.cwd()).resolve(strict=False)
@@ -193,7 +196,7 @@ class SandboxRunner:
         *,
         env: dict[str, str] | None = None,
         input_text: str | None = None,
-        timeout_seconds: int | None = None,
+        timeout_seconds: float | None = None,
     ) -> CommandResult:
         sandbox_command = self.build_command(command)
         pass_fds: tuple[int, ...] = ()
@@ -232,3 +235,67 @@ class SandboxRunner:
             stderr=completed.stderr[: self.output_limit],
             stdout=completed.stdout[: self.output_limit],
         )
+
+    async def run_async(
+        self,
+        command: list[str],
+        *,
+        env: dict[str, str] | None = None,
+        input_text: str | None = None,
+        timeout_seconds: float | None = None,
+    ) -> CommandResult:
+        sandbox_command = self.build_command(command)
+        pass_fds: tuple[int, ...] = ()
+        if sandbox_command.seccomp_file is not None:
+            pass_fds = (sandbox_command.seccomp_file.fileno(),)
+
+        process_env = os.environ.copy()
+        if env is not None:
+            process_env.update(env)
+        process = await asyncio.create_subprocess_exec(
+            *sandbox_command.args,
+            cwd=self.cwd,
+            env=process_env,
+            pass_fds=pass_fds,
+            start_new_session=True,
+            stdin=asyncio.subprocess.PIPE if input_text is not None else None,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(
+                    input_text.encode() if input_text is not None else None
+                ),
+                timeout=timeout_seconds or self.timeout_seconds,
+            )
+        except TimeoutError as error:
+            with suppress(ProcessLookupError):
+                os.killpg(process.pid, signal.SIGKILL)
+            stdout, stderr = await process.communicate()
+            return CommandResult(
+                command=" ".join(command),
+                exit_code=124,
+                stderr=str(error) or "Command timed out.",
+                stdout=self._text_output(stdout)[: self.output_limit],
+            )
+        except asyncio.CancelledError:
+            with suppress(ProcessLookupError):
+                os.killpg(process.pid, signal.SIGTERM)
+            try:
+                await asyncio.wait_for(process.wait(), timeout=1)
+            except TimeoutError:
+                with suppress(ProcessLookupError):
+                    os.killpg(process.pid, signal.SIGKILL)
+                await process.wait()
+            raise
+        finally:
+            if sandbox_command.seccomp_file is not None:
+                sandbox_command.seccomp_file.close()
+
+        return CommandResult(
+            command=" ".join(command),
+            exit_code=process.returncode or 0,
+            stderr=self._text_output(stderr)[: self.output_limit],
+            stdout=self._text_output(stdout)[: self.output_limit],
+        )