flowent 0.2.2 → 0.2.4

package/backend/pyproject.toml

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

package/backend/src/flowent/agent.py

@@ -240,6 +240,7 @@ async def run_agent_stream(
             round_number,
             tool_calls,
         )
+        yield AgentStreamEvent(event="output_done", data={"index": round_number})
         if not tool_calls:
             if not final_content and not final_thinking:
                 raise RuntimeError(EMPTY_MODEL_RESPONSE_ERROR)

package/backend/src/flowent/context.py

@@ -4,6 +4,7 @@ import os
 from pathlib import Path
 
 from flowent.llm import ChatMessage
+from flowent.shell import shell_invocation_description
 from flowent.tools import tool_specs
 
 DEFAULT_PROJECT_INSTRUCTIONS_MAX_BYTES = 32768
@@ -108,6 +109,7 @@ def environment_context_message(cwd: Path) -> ChatMessage:
         content=(
             "<environment_context>\n"
             f"  <cwd>{cwd.resolve(strict=False)}</cwd>\n"
+            f"  <shell>{shell_invocation_description()}</shell>\n"
             "  <filesystem>workspace-write</filesystem>\n"
             "  <network>enabled</network>\n"
             "  <tools>\n"

package/backend/src/flowent/llm.py

@@ -108,6 +108,7 @@ MODEL_PREFIXES: dict[ProviderFormat, str] = {
     ProviderFormat.ANTHROPIC: "anthropic",
     ProviderFormat.GEMINI: "gemini",
 }
+OPENAI_RESPONSES_MODEL_PREFIX = "responses/"
 _litellm_stream_error_patch_installed = False
 
 PROVIDER_API_VERSIONS: dict[ProviderFormat, str] = {
@@ -121,7 +122,10 @@ VERSION_PATH_SEGMENT = re.compile(r"^v\d+(?:[a-z]+)?$", re.IGNORECASE)
 
 
 def provider_model_name(connection: ProviderConnection) -> str:
-    return f"{MODEL_PREFIXES[connection.provider]}/{connection.model}"
+    model = normalize_provider_model_name(connection.provider, connection.model)
+    if connection.provider == ProviderFormat.OPENAI_RESPONSES:
+        model = f"{OPENAI_RESPONSES_MODEL_PREFIX}{model}"
+    return f"{MODEL_PREFIXES[connection.provider]}/{model}"
 
 
 def provider_litellm_name(provider: ProviderFormat) -> str:
@@ -164,23 +168,20 @@ def normalize_provider_base_url(
 
 def normalize_provider_model_name(provider: ProviderFormat, model: str) -> str:
     prefix = f"{provider_litellm_name(provider)}/"
-    if model.startswith(prefix):
-        return model.removeprefix(prefix)
-    return model
+    normalized_model = model.removeprefix(prefix) if model.startswith(prefix) else model
+    if provider == ProviderFormat.OPENAI_RESPONSES:
+        return normalized_model.removeprefix(OPENAI_RESPONSES_MODEL_PREFIX)
+    return normalized_model
 
 
 def stream_failure_message(chunk: Any) -> str:
-    if isinstance(chunk, BaseModel):
-        chunk = chunk.model_dump()
-    if not isinstance(chunk, Mapping):
-        return ""
-
-    event_type = getattr(chunk.get("type"), "value", chunk.get("type"))
+    event_type = value_at(chunk, "type", "")
+    event_type = getattr(event_type, "value", event_type)
     event_type = str(event_type or "")
     if event_type == "error":
-        error = chunk.get("error", {})
+        error = value_at(chunk, "error", {})
     elif event_type == "response.failed":
-        response = chunk.get("response", {})
+        response = value_at(chunk, "response", {})
         error = value_at(response, "error", {})
     else:
         return ""

package/backend/src/flowent/logging.py

@@ -194,6 +194,12 @@ class ConsoleNoiseFilter(logging.Filter):
         return record.levelno > logging.DEBUG or record.name.startswith("flowent")
 
 
+class ConsoleHandler(logging.StreamHandler):
+    def emit(self, record: logging.LogRecord) -> None:
+        self.setStream(sys.stderr if record.levelno >= logging.WARNING else sys.stdout)
+        super().emit(record)
+
+
 def configure_logging(*, directory: Path | None = None) -> Path:
     global _configured_log_file, _configured_log_process_id
 
@@ -218,7 +224,7 @@ def configure_logging(*, directory: Path | None = None) -> Path:
         )
     )
 
-    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler = ConsoleHandler()
     console_handler.setLevel(console_log_level())
     console_handler.setFormatter(
         RedactingFormatter("%(levelname)s %(name)s: %(message)s")

package/backend/src/flowent/main.py

@@ -1,12 +1,14 @@
 import asyncio
+import copy
 import json
 import logging
 import os
-from collections.abc import AsyncIterator, Mapping, Sequence
+import time
+from collections.abc import AsyncIterator, Awaitable, Mapping, Sequence
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal
+from typing import Any, Literal
 from uuid import uuid4
 
 from fastapi import FastAPI, HTTPException, Query
@@ -89,6 +91,7 @@ DEFAULT_AUTO_COMPACT_CONTEXT_WINDOW_RATIO = 0.95
 AUTO_COMPACT_RETAINED_MESSAGE_TOKEN_BUDGET = 20_000
 APPROVAL_TRANSCRIPT_MESSAGE_LIMIT = 12
 APPROVAL_TRANSCRIPT_TEXT_LIMIT = 2_000
+WORKSPACE_PROGRESS_FLUSH_INTERVAL_SECONDS = 0.5
 
 
 class ProviderModelsRequest(BaseModel):
@@ -180,6 +183,7 @@ class WritablePathListResponse(BaseModel):
 @dataclass
 class WorkspaceRun:
     condition: asyncio.Condition
+    active_output: Literal["text", "thinking"] | None = None
     discard_on_cancel: bool = False
     events: list[tuple[int, str, dict[str, object]]] = field(default_factory=list)
     generation: int = 0
@@ -200,8 +204,13 @@ def stream_event(
     return f"{id_line}event: {event}\ndata: {json.dumps(data)}\n\n"
 
 
-def stream_message_data(message: StoredMessage) -> dict[str, object]:
-    return {**message.model_dump(), "status": message.status}
+def stream_message_data(
+    message: StoredMessage, active_output: Literal["text", "thinking"] | None = None
+) -> dict[str, object]:
+    data = {**message.model_dump(), "status": message.status}
+    if active_output is not None:
+        data["active_output"] = active_output
+    return data
 
 
 def append_or_replace_message(
@@ -216,13 +225,131 @@ def append_or_replace_message(
 def run_snapshot_data_at(
     run: WorkspaceRun, event_index: int
 ) -> dict[str, object] | None:
-    for current_event_index, event, data in reversed(run.events):
-        if current_event_index > event_index or event != "snapshot":
+    snapshot_event_index = 0
+    snapshot: dict[str, object] | None = None
+    for current_event_index, event, data in run.events:
+        if current_event_index > event_index:
+            break
+        if event != "snapshot":
+            if event == "start" and snapshot is None:
+                assistant_id = data.get("id")
+                if isinstance(assistant_id, str):
+                    snapshot_event_index = current_event_index
+                    snapshot = {
+                        "author": "assistant",
+                        "content": "",
+                        "groups": [],
+                        "id": assistant_id,
+                        "status": "running",
+                        "tools": [],
+                    }
             continue
         message = data.get("message")
         if isinstance(message, dict):
-            return message
-    return None
+            snapshot_event_index = current_event_index
+            snapshot = copy.deepcopy(message)
+    if snapshot is None:
+        return None
+    for current_event_index, event, data in run.events:
+        if current_event_index <= snapshot_event_index:
+            continue
+        if current_event_index > event_index:
+            break
+        apply_stream_event_to_snapshot(snapshot, event, data)
+    return snapshot
+
+
+def apply_stream_event_to_snapshot(
+    snapshot: dict[str, object], event: str, data: dict[str, object]
+) -> None:
+    if event == "output_start":
+        snapshot.pop("active_output", None)
+        index = data.get("index")
+        if isinstance(index, int):
+            append_snapshot_group(snapshot, index)
+    if event == "delta":
+        append_snapshot_text(snapshot, str(data.get("content") or ""))
+    if event == "thinking_delta":
+        append_snapshot_thinking(snapshot, str(data.get("content") or ""))
+    if event == "output_done":
+        snapshot.pop("active_output", None)
+
+
+def snapshot_groups(snapshot: dict[str, object]) -> list[dict[str, object]]:
+    groups = snapshot.get("groups")
+    if not isinstance(groups, list):
+        groups = []
+        snapshot["groups"] = groups
+    return groups
+
+
+def append_snapshot_group(
+    snapshot: dict[str, object], index: int | None = None
+) -> None:
+    groups = snapshot_groups(snapshot)
+    assistant_id = str(snapshot.get("id") or "assistant")
+    group_index = index if index is not None else len(groups) + 1
+    group_id = f"{assistant_id}-group-{group_index}"
+    if groups and groups[-1].get("id") == group_id:
+        return
+    groups.append({"id": group_id, "items": []})
+
+
+def append_snapshot_text(snapshot: dict[str, object], content: str) -> None:
+    if not content:
+        return
+    snapshot["active_output"] = "text"
+    snapshot["content"] = f"{snapshot.get('content') or ''}{content}"
+    append_snapshot_item_content(snapshot, content, "text")
+
+
+def append_snapshot_thinking(snapshot: dict[str, object], content: str) -> None:
+    if not content:
+        return
+    snapshot["active_output"] = "thinking"
+    snapshot["thinking"] = f"{snapshot.get('thinking') or ''}{content}"
+    append_snapshot_item_content(snapshot, content, "thinking")
+
+
+def append_snapshot_item_content(
+    snapshot: dict[str, object], content: str, item_type: Literal["text", "thinking"]
+) -> None:
+    groups = snapshot_groups(snapshot)
+    if not groups:
+        append_snapshot_group(snapshot)
+    group = groups[-1]
+    items = group.get("items")
+    if not isinstance(items, list):
+        items = []
+        group["items"] = items
+    item = next(
+        (
+            current
+            for current in reversed(items)
+            if isinstance(current, dict) and current.get("type") == item_type
+        ),
+        None,
+    )
+    if item is None:
+        assistant_id = str(snapshot.get("id") or "assistant")
+        snapshot_item_count = 0
+        for current_group in groups:
+            current_items = current_group.get("items")
+            if not isinstance(current_items, list):
+                continue
+            snapshot_item_count += sum(
+                1
+                for current_item in current_items
+                if isinstance(current_item, dict)
+                and current_item.get("type") == item_type
+            )
+        item = {
+            "content": "",
+            "id": f"{assistant_id}-{item_type}-{snapshot_item_count + 1}",
+            "type": item_type,
+        }
+        items.append(item)
+    item["content"] = f"{item.get('content') or ''}{content}"
 
 
 USER_VISIBLE_RUN_ERROR_TITLE = "Request failed"
@@ -1007,6 +1134,58 @@ def create_app(
         telegram_transport=telegram_transport,
     )
 
+    async def gather_shutdown_tasks(
+        label: str, tasks: Sequence[asyncio.Task[Any]]
+    ) -> None:
+        if not tasks:
+            return
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        for result in results:
+            if result is None or isinstance(result, asyncio.CancelledError):
+                continue
+            if isinstance(result, BaseException):
+                logger.error(
+                    "%s cleanup task failed",
+                    label,
+                    exc_info=(type(result), result, result.__traceback__),
+                )
+
+    async def stop_workspace_runs_for_shutdown() -> None:
+        tasks: list[asyncio.Task[None]] = []
+        for run in workspace_runs.values():
+            if run.task is None or run.task.done():
+                continue
+            run.task.cancel()
+            tasks.append(run.task)
+        await gather_shutdown_tasks("Workspace run", tasks)
+
+    async def stop_workspace_compact_for_shutdown() -> None:
+        nonlocal active_compact_task
+        if active_compact_task is None:
+            store.save_is_compacting(False)
+            return
+        task = active_compact_task.task
+        active_compact_task = None
+        if not task.done():
+            task.cancel()
+        await gather_shutdown_tasks("Workspace compact", [task])
+        store.save_is_compacting(False)
+
+    async def run_shutdown_step(label: str, cleanup: Awaitable[object]) -> None:
+        try:
+            await cleanup
+        except Exception:
+            logger.exception("%s cleanup failed during shutdown", label)
+
+    async def graceful_shutdown() -> None:
+        await run_shutdown_step("Workspace run", stop_workspace_runs_for_shutdown())
+        await run_shutdown_step(
+            "Workspace compact", stop_workspace_compact_for_shutdown()
+        )
+        if telegram_bot_manager is not None:
+            await run_shutdown_step("Telegram", telegram_bot_manager.stop_all())
+        await run_shutdown_step("MCP", mcp_manager.stop_all())
+
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncIterator[None]:
         app.state.mcp_manager = mcp_manager
@@ -1017,9 +1196,7 @@ def create_app(
         try:
             yield
         finally:
-            if telegram_bot_manager is not None:
-                await telegram_bot_manager.stop_all()
-            await mcp_manager.stop_all()
+            await graceful_shutdown()
 
     app = FastAPI(title="Flowent", lifespan=lifespan)
     app.state.mcp_manager = mcp_manager
@@ -1061,6 +1238,11 @@ def create_app(
     async def save_provider(provider: StoredProvider) -> StoredProvider:
         return store.save_provider(provider)
 
+    @app.delete("/api/providers/{provider_id}")
+    async def delete_provider(provider_id: str) -> dict[str, bool]:
+        store.delete_provider(provider_id)
+        return {"ok": True}
+
     @app.put("/api/mcp/servers")
     async def save_mcp_server(server: StoredMcpServer) -> StoredMcpServer:
         saved_server = store.save_mcp_server(server)
@@ -1204,7 +1386,7 @@ def create_app(
         await append_run_event(
             run,
             "snapshot",
-            {"message": stream_message_data(message)},
+            {"message": stream_message_data(message, run.active_output)},
         )
 
     def active_workspace_run() -> WorkspaceRun | None:
@@ -1258,11 +1440,14 @@ def create_app(
                 status="running",
             )
             assistant_output = AssistantOutputBuilder(assistant_message.id)
+            last_progress_flush_at = 0.0
 
             def is_current_generation() -> bool:
                 return run.generation == workspace_generation
 
-            def persist_assistant(status: str = "running") -> StoredMessage | None:
+            def update_assistant_message(
+                status: str = "running", *, persist: bool
+            ) -> StoredMessage | None:
                 nonlocal next_messages, assistant_message
                 if not is_current_generation() or run.discard_on_cancel:
                     return None
@@ -1279,9 +1464,33 @@ def create_app(
                 next_messages = append_or_replace_message(
                     next_messages, assistant_message
                 )
-                store.upsert_message(assistant_message)
+                if persist:
+                    store.upsert_message(assistant_message)
                 return assistant_message
 
+            def persist_assistant(status: str = "running") -> StoredMessage | None:
+                nonlocal last_progress_flush_at
+                message = update_assistant_message(status, persist=True)
+                if status == "running" and message is not None:
+                    last_progress_flush_at = time.monotonic()
+                return message
+
+            def refresh_assistant(status: str = "running") -> StoredMessage | None:
+                return update_assistant_message(status, persist=False)
+
+            def persist_assistant_progress() -> StoredMessage | None:
+                nonlocal last_progress_flush_at
+                now = time.monotonic()
+                if (
+                    last_progress_flush_at > 0
+                    and now - last_progress_flush_at
+                    < WORKSPACE_PROGRESS_FLUSH_INTERVAL_SECONDS
+                ):
+                    refresh_assistant()
+                    return None
+                last_progress_flush_at = now
+                return update_assistant_message("running", persist=True)
+
             try:
                 current_tool_id: str | None = None
                 turn_usage_info: TokenUsageInfo | None = None
@@ -1445,11 +1654,15 @@ def create_app(
                     if event.event == "output_start":
                         index = event.data.get("index")
                         if isinstance(index, int):
+                            run.active_output = None
                             assistant_output.start_group(index)
                             snapshot_after_event = persist_assistant()
+                    if event.event == "output_done":
+                        run.active_output = None
                     if event.event == "tool_start":
                         tool = event.data.get("tool")
                         if isinstance(tool, dict) and isinstance(tool.get("id"), str):
+                            run.active_output = None
                             current_tool_id = tool["id"]
                             assistant_output.start_tool(
                                 StoredToolItem.model_validate(tool)
@@ -1467,15 +1680,17 @@ def create_app(
                             assistant_output.update_tool(tool_id, event.data)
                             snapshot_after_event = persist_assistant()
                     if event.event == "delta":
+                        run.active_output = "text"
                         assistant_output.append_text(
                             str(event.data.get("content") or "")
                         )
-                        snapshot_after_event = persist_assistant()
+                        snapshot_after_event = persist_assistant_progress()
                     if event.event == "thinking_delta":
+                        run.active_output = "thinking"
                         assistant_output.append_thinking(
                             str(event.data.get("content") or "")
                         )
-                        snapshot_after_event = persist_assistant()
+                        snapshot_after_event = persist_assistant_progress()
                     if event.event == "usage":
                         usage_data = event.data.get("usage")
                         if isinstance(usage_data, dict):
@@ -1503,6 +1718,7 @@ def create_app(
                     if event.event == "done":
                         message = event.data.get("message")
                         if isinstance(message, dict):
+                            run.active_output = None
                             assistant_output.apply_done_message(message)
                             response_usage_info = store.read_usage_info()
                             final_usage_info = turn_usage_info