flowent 0.1.1 → 0.1.2

package/backend/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowent"
-version = "0.1.1"
+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
@@ -119,6 +120,15 @@ 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:
@@ -312,6 +322,7 @@ def create_app(
             author="assistant",
             content=assistant_content,
             id=assistant_id,
+            status="completed",
             thinking=assistant_thinking,
             tools=list(assistant_tools.values()),
         )
@@ -541,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,
@@ -551,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:
@@ -568,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",
@@ -577,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/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],
+        )

package/backend/src/flowent/storage.py

@@ -105,6 +105,9 @@ class StoredMessage(BaseModel):
     author: str
     content: str
     id: str
+    status: str = Field(
+        default="completed", exclude_if=lambda value: value == "completed"
+    )
     thinking: str = Field(default="", exclude_if=lambda value: value == "")
     tools: list[StoredToolItem] = Field(default_factory=list)
 
@@ -168,6 +171,7 @@ class StateStore:
                     author=row["author"],
                     content=row["content"],
                     id=row["id"],
+                    status=row["status"],
                     thinking=row["thinking"],
                     tools=[
                         StoredToolItem.model_validate(tool)
@@ -176,7 +180,7 @@ class StateStore:
                 )
                 for row in connection.execute(
                     """
-                    SELECT id, author, content, tools, thinking
+                    SELECT id, author, content, tools, thinking, status
                     FROM messages
                     ORDER BY position, id
                     """
@@ -476,8 +480,8 @@ class StateStore:
             connection.execute("DELETE FROM messages")
             connection.executemany(
                 """
-                INSERT INTO messages (id, author, content, tools, thinking, position)
-                VALUES (?, ?, ?, ?, ?, ?)
+                INSERT INTO messages (id, author, content, tools, thinking, status, position)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
                 """,
                 [
                     (
@@ -491,6 +495,7 @@ class StateStore:
                             ]
                         ),
                         message.thinking,
+                        message.status,
                         position,
                     )
                     for position, message in enumerate(messages)
@@ -500,6 +505,44 @@ class StateStore:
                 connection.execute("DELETE FROM workspace_context WHERE id = 1")
         return messages
 
+    def upsert_message(self, message: StoredMessage) -> StoredMessage:
+        with self.connect() as connection:
+            row = connection.execute(
+                "SELECT position FROM messages WHERE id = ?", (message.id,)
+            ).fetchone()
+            if row:
+                position = row["position"]
+            else:
+                position_row = connection.execute(
+                    "SELECT COALESCE(MAX(position) + 1, 0) AS position FROM messages"
+                ).fetchone()
+                position = position_row["position"]
+            connection.execute(
+                """
+                INSERT INTO messages (id, author, content, tools, thinking, status, position)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                    author = excluded.author,
+                    content = excluded.content,
+                    tools = excluded.tools,
+                    thinking = excluded.thinking,
+                    status = excluded.status,
+                    position = excluded.position
+                """,
+                (
+                    message.id,
+                    message.author,
+                    message.content,
+                    json.dumps(
+                        [tool.model_dump(exclude_none=True) for tool in message.tools]
+                    ),
+                    message.thinking,
+                    message.status,
+                    position,
+                ),
+            )
+        return message
+
     def read_compacted_context(self) -> str:
         with self.connect() as connection:
             row = connection.execute(
@@ -698,6 +741,7 @@ class StateStore:
                 id TEXT PRIMARY KEY,
                 author TEXT NOT NULL,
                 content TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'completed',
                 position INTEGER NOT NULL
             );
 
@@ -741,6 +785,10 @@ class StateStore:
             connection.execute(
                 "ALTER TABLE messages ADD COLUMN thinking TEXT NOT NULL DEFAULT ''"
             )
+        if "status" not in columns:
+            connection.execute(
+                "ALTER TABLE messages ADD COLUMN status TEXT NOT NULL DEFAULT 'completed'"
+            )
         settings_columns = {
             row["name"] for row in connection.execute("PRAGMA table_info(settings)")
         }

package/backend/src/flowent/tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import json
 import subprocess
 import sys
@@ -198,6 +199,22 @@ def run_tool(
         return ToolResult(content=str(error), ok=False, title=title)
 
 
+async def run_tool_async(
+    name: str, arguments: dict[str, object], context: ToolContext
+) -> ToolResult:
+    try:
+        if name == "shell_command":
+            return await shell_command_async(arguments, context)
+        if name == "apply_patch":
+            return await apply_patch_tool_async(arguments, context)
+        return await asyncio.to_thread(run_tool, name, arguments, context)
+    except Exception as error:
+        title = (
+            "Edit failed" if name == "apply_patch" else tool_call_title(name, arguments)
+        )
+        return ToolResult(content=str(error), ok=False, title=title)
+
+
 def integer_argument(arguments: dict[str, object], name: str, default: int) -> int:
     value = arguments.get(name, default)
     if isinstance(value, int):
@@ -207,6 +224,15 @@ def integer_argument(arguments: dict[str, object], name: str, default: int) -> i
     return default
 
 
+def number_argument(arguments: dict[str, object], name: str, default: float) -> float:
+    value = arguments.get(name, default)
+    if isinstance(value, int | float):
+        return float(value)
+    if isinstance(value, str):
+        return float(value)
+    return default
+
+
 def read_file(arguments: dict[str, object], context: ToolContext) -> ToolResult:
     path = resolve_tool_path(str(arguments["path"]), context.cwd)
     offset = integer_argument(arguments, "offset", 0)
@@ -271,6 +297,28 @@ def apply_patch_tool(arguments: dict[str, object], context: ToolContext) -> Tool
     )
 
 
+async def apply_patch_tool_async(
+    arguments: dict[str, object], context: ToolContext
+) -> ToolResult:
+    patch = str(arguments["patch"])
+    paths = affected_paths(patch, context.cwd)
+    runner = SandboxRunner(cwd=context.cwd)
+    for path in paths:
+        runner.ensure_writable_path(path)
+    result = await runner.run_async(
+        [sys.executable, "-m", "flowent.cli", "apply-patch", "--cwd", str(context.cwd)],
+        input_text=patch,
+    )
+    if result.exit_code != 0:
+        raise SandboxError(tool_failure_content(result))
+    data = json.loads(result.stdout or "{}")
+    return ToolResult(
+        content=result.stdout,
+        data=data if isinstance(data, dict) else {},
+        title=patch_title_from_result(data),
+    )
+
+
 def patch_title_from_result(data: object) -> str:
     if not isinstance(data, dict):
         return "Edited files"
@@ -308,7 +356,7 @@ def tool_failure_content(result: object) -> str:
 
 def shell_command(arguments: dict[str, object], context: ToolContext) -> ToolResult:
     command = str(arguments["command"])
-    timeout_seconds = integer_argument(arguments, "timeout_seconds", 30)
+    timeout_seconds = number_argument(arguments, "timeout_seconds", 30)
     result = SandboxRunner(cwd=context.cwd).run(
         ["/bin/sh", "-c", command], timeout_seconds=timeout_seconds
     )
@@ -327,6 +375,29 @@ def shell_command(arguments: dict[str, object], context: ToolContext) -> ToolRes
     )
 
 
+async def shell_command_async(
+    arguments: dict[str, object], context: ToolContext
+) -> ToolResult:
+    command = str(arguments["command"])
+    timeout_seconds = number_argument(arguments, "timeout_seconds", 30)
+    result = await SandboxRunner(cwd=context.cwd).run_async(
+        ["/bin/sh", "-c", command], timeout_seconds=timeout_seconds
+    )
+    ok = result.exit_code == 0
+    content = result.stdout or result.stderr
+    return ToolResult(
+        content=content,
+        data={
+            "command": command,
+            "exit_code": result.exit_code,
+            "stderr": result.stderr,
+            "stdout": result.stdout,
+        },
+        ok=ok,
+        title=f"Ran {command}",
+    )
+
+
 def update_plan(arguments: dict[str, object]) -> ToolResult:
     items = arguments.get("items", [])
     content = json.dumps(items, ensure_ascii=False)

package/backend/tests/test_agent_tools.py

@@ -1,11 +1,15 @@
+import asyncio
 import json
+import time
 from pathlib import Path
 
+import pytest
 from fastapi.testclient import TestClient
 
-from flowent.agent import FLOWENT_AGENT_SYSTEM_PROMPT
+from flowent.agent import FLOWENT_AGENT_SYSTEM_PROMPT, run_agent_stream
+from flowent.llm import ProviderConnection, ProviderFormat
 from flowent.main import create_app
-from flowent.sandbox import SandboxRunner
+from flowent.sandbox import SandboxCommand, SandboxRunner
 from flowent.tools import ToolContext, run_tool
 
 
@@ -222,6 +226,103 @@ def test_shell_command_has_network_by_default(tmp_path) -> None:
     assert "network-ready" in result.content
 
 
+@pytest.mark.anyio
+async def test_async_shell_command_does_not_block_other_tasks(
+    tmp_path, monkeypatch
+) -> None:
+    runner = SandboxRunner(cwd=tmp_path)
+    command = [
+        "/bin/sh",
+        "-c",
+        "python - <<'PY'\nimport time\ntime.sleep(0.2)\nprint('done')\nPY",
+    ]
+    monkeypatch.setattr(
+        runner,
+        "build_command",
+        lambda command: SandboxCommand(command, seccomp_available=False),
+    )
+    command_task = asyncio.create_task(runner.run_async(command, timeout_seconds=1))
+    start = time.perf_counter()
+    await asyncio.sleep(0.01)
+    elapsed = time.perf_counter() - start
+    result = await command_task
+
+    assert elapsed < 0.1
+    assert result.exit_code == 0
+    assert "done" in result.stdout
+
+
+@pytest.mark.anyio
+async def test_async_shell_command_timeout_returns_failed_result(
+    tmp_path, monkeypatch
+) -> None:
+    runner = SandboxRunner(cwd=tmp_path)
+    command = [
+        "/bin/sh",
+        "-c",
+        "python - <<'PY'\nimport time\ntime.sleep(1)\nprint('late')\nPY",
+    ]
+    monkeypatch.setattr(
+        runner,
+        "build_command",
+        lambda command: SandboxCommand(command, seccomp_available=False),
+    )
+    result = await runner.run_async(
+        command,
+        timeout_seconds=0.05,
+    )
+
+    assert result.exit_code == 124
+    assert "late" not in result.stdout
+
+
+@pytest.mark.anyio
+async def test_agent_stream_stops_after_cancelled_tool(tmp_path) -> None:
+    cancelled = False
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield tool_call_chunk("shell_command", {"command": "slow"})
+
+        return chunks()
+
+    async def fake_runner(
+        name: str, arguments: dict[str, object], context: ToolContext
+    ):
+        nonlocal cancelled
+        try:
+            await asyncio.sleep(10)
+        except asyncio.CancelledError:
+            cancelled = True
+            raise
+
+    stream = run_agent_stream(
+        completion=fake_completion,
+        connection=ProviderConnection(
+            base_url=None,
+            model="gpt-5.1",
+            name="OpenAI",
+            provider=ProviderFormat.OPENAI,
+            secret_reference="sk-local",
+        ),
+        cwd=tmp_path,
+        messages=[{"role": "user", "content": "Run it."}],
+        tool_runner=fake_runner,
+    )
+
+    await stream.__anext__()
+    await stream.__anext__()
+    await stream.__anext__()
+    next_event = asyncio.create_task(stream.__anext__())
+    await asyncio.sleep(0)
+    next_event.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await next_event
+    await stream.aclose()
+
+    assert cancelled
+
+
 def test_shell_command_denies_ptrace_when_seccomp_is_available(tmp_path) -> None:
     command = SandboxRunner(cwd=tmp_path).build_command(["/bin/true"])
     if not command.seccomp_available:

package/backend/tests/test_workspace_chat.py

@@ -1,11 +1,17 @@
+import asyncio
+import time
+
+import httpx
+import pytest
 from fastapi.testclient import TestClient
 
 from flowent.agent import FLOWENT_AGENT_SYSTEM_PROMPT
 from flowent.main import create_app
+from flowent.sandbox import CommandResult, SandboxRunner
 
 
 def configure_provider(
-    client: TestClient,
+    client,
     *,
     base_url: str = "",
     model: str = "gpt-5.1",
@@ -35,6 +41,37 @@ def configure_provider(
     )
 
 
+async def configure_provider_async(
+    client: httpx.AsyncClient,
+    *,
+    base_url: str = "",
+    model: str = "gpt-5.1",
+    name: str = "OpenAI",
+    provider_id: str = "provider-openai",
+    provider_type: str = "openai",
+    reasoning_effort: str = "default",
+) -> None:
+    await client.post(
+        "/api/providers",
+        json={
+            "api_key": "sk-local",
+            "base_url": base_url,
+            "id": provider_id,
+            "models": [model],
+            "name": name,
+            "type": provider_type,
+        },
+    )
+    await client.put(
+        "/api/settings",
+        json={
+            "reasoning_effort": reasoning_effort,
+            "selected_model": model,
+            "selected_provider_id": provider_id,
+        },
+    )
+
+
 def project_context_message(request: dict[str, object]) -> dict[str, object] | None:
     for message in request["messages"]:
         if str(message["content"]).startswith("# AGENTS.md instructions for "):
@@ -63,6 +100,88 @@ def stream_events(content: str) -> list[dict[str, object]]:
     return events
 
 
+def tool_call_chunk(
+    name: str,
+    arguments: str,
+    *,
+    call_id: str = "call-1",
+) -> dict[str, object]:
+    return {
+        "choices": [
+            {
+                "delta": {
+                    "tool_calls": [
+                        {
+                            "index": 0,
+                            "id": call_id,
+                            "type": "function",
+                            "function": {
+                                "arguments": arguments,
+                                "name": name,
+                            },
+                        }
+                    ]
+                }
+            }
+        ]
+    }
+
+
+@pytest.mark.anyio
+async def test_workspace_long_shell_command_does_not_block_health(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    command_started = asyncio.Event()
+    command_can_finish = asyncio.Event()
+
+    async def fake_run_async(self, command, **kwargs):
+        command_started.set()
+        await asyncio.wait_for(command_can_finish.wait(), timeout=2)
+        return CommandResult(
+            command=" ".join(command),
+            exit_code=0,
+            stderr="",
+            stdout="slow command finished",
+        )
+
+    monkeypatch.setattr(SandboxRunner, "run_async", fake_run_async)
+
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+
+        async def chunks() -> object:
+            if len(captured_requests) == 1:
+                yield tool_call_chunk("shell_command", '{"command": "slow"}')
+            else:
+                yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    app = create_app(serve_frontend=False, chat_completion=fake_completion)
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+    ) as client:
+        await configure_provider_async(client)
+        response_task = asyncio.create_task(
+            client.post("/api/workspace/respond", json={"content": "Run slow."})
+        )
+        await asyncio.wait_for(command_started.wait(), timeout=2)
+        start = time.perf_counter()
+        health_response = await client.get("/api/health")
+        elapsed = time.perf_counter() - start
+        command_can_finish.set()
+        response = await response_task
+
+    assert health_response.status_code == 200
+    assert health_response.json() == {"status": "ok"}
+    assert elapsed < 0.2
+    assert response.status_code == 200
+
+
 def test_workspace_response_streams_selected_provider_model_and_history(
     tmp_path, monkeypatch
 ) -> None:
@@ -604,3 +723,152 @@ def test_project_instructions_are_truncated_to_size_limit(
     assert project_message is not None
     assert "1234567890ab" in project_message["content"]
     assert "cdef" not in project_message["content"]
+
+
+@pytest.mark.anyio
+async def test_workspace_persists_tool_start_during_stream(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    command_started = asyncio.Event()
+    command_can_finish = asyncio.Event()
+
+    async def fake_run_async(self, command, **kwargs):
+        command_started.set()
+        await asyncio.wait_for(command_can_finish.wait(), timeout=2)
+        return CommandResult(
+            command=" ".join(command),
+            exit_code=0,
+            stderr="",
+            stdout="Launch notes",
+        )
+
+    monkeypatch.setattr(SandboxRunner, "run_async", fake_run_async)
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            if request["messages"][-1]["role"] == "user":
+                yield tool_call_chunk("shell_command", '{"command": "slow"}')
+            else:
+                yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    app = create_app(serve_frontend=False, chat_completion=fake_completion)
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+    ) as client:
+        await configure_provider_async(client)
+        response_task = asyncio.create_task(
+            client.post("/api/workspace/respond", json={"content": "Read notes."})
+        )
+        await asyncio.wait_for(command_started.wait(), timeout=2)
+        state = (await client.get("/api/state")).json()
+        command_can_finish.set()
+        response = await response_task
+
+    assistant = state["messages"][-1]
+    assert response.status_code == 200
+    assert assistant["author"] == "assistant"
+    assert assistant["status"] == "running"
+    assert assistant["tools"][0]["name"] == "shell_command"
+    assert assistant["tools"][0]["status"] == "running"
+
+
+@pytest.mark.anyio
+async def test_workspace_persists_tool_result_during_stream(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    (tmp_path / "notes.txt").write_text("Launch notes")
+    second_round_started = asyncio.Event()
+    continue_stream = asyncio.Event()
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            if request["messages"][-1]["role"] == "user":
+                yield tool_call_chunk("read_file", '{"path": "notes.txt"}')
+                return
+            second_round_started.set()
+            await asyncio.wait_for(continue_stream.wait(), timeout=2)
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    app = create_app(serve_frontend=False, chat_completion=fake_completion)
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+    ) as client:
+        await configure_provider_async(client)
+        response_task = asyncio.create_task(
+            client.post("/api/workspace/respond", json={"content": "Read notes."})
+        )
+        await asyncio.wait_for(second_round_started.wait(), timeout=2)
+        state = (await client.get("/api/state")).json()
+        continue_stream.set()
+        response = await response_task
+
+    assistant = state["messages"][-1]
+    assert response.status_code == 200
+    assert assistant["status"] == "running"
+    assert assistant["tools"][0]["status"] == "success"
+    assert assistant["tools"][0]["content"] == "Launch notes"
+
+
+def test_workspace_persists_failed_draft_when_stream_errors(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Partial answer."}}]}
+            raise RuntimeError("provider stopped")
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["author"] == "assistant"
+    assert assistant["content"] == "Partial answer."
+    assert assistant["status"] == "failed"
+
+
+def test_workspace_marks_draft_complete_when_stream_finishes(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["author"] == "assistant"
+    assert assistant["content"] == "Done."
+    assert assistant.get("status", "completed") == "completed"

package/backend/uv.lock

@@ -462,7 +462,7 @@ wheels = [
 
 [[package]]
 name = "flowent"
-version = "0.1.1"
+version = "0.1.2"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi", extra = ["standard"] },

package/bin/flowent.mjs

@@ -70,7 +70,7 @@ const child = spawn(
   uvCommand,
   ["run", "--project", backendProject, "flowent", ...passthroughArgs],
   {
-    cwd: packageRoot,
+    cwd: process.cwd(),
     stdio: "inherit",
     env: {
       ...process.env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowent",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A workflow orchestration platform for multi-agent collaboration.",
   "author": "ImFeH2 <i@feh2.im>",
   "license": "Apache-2.0",