flowent 0.2.2__tar.gz → 0.2.3__tar.gz

{flowent-0.2.2 → flowent-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowent
-Version: 0.2.2
+Version: 0.2.3
 Summary: A workflow orchestration platform for multi-agent collaboration
 Keywords: agent,agents,ai,ai-agents,assistant,automation,code-generation,llm,mcp,orchestration,sandbox,web-application,workflow
 Author: ImFeH2

{flowent-0.2.2 → flowent-0.2.3}/pyproject.toml

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

{flowent-0.2.2 → flowent-0.2.3}/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)

{flowent-0.2.2 → flowent-0.2.3}/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"

{flowent-0.2.2 → flowent-0.2.3}/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,9 +168,10 @@ 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:

{flowent-0.2.2 → flowent-0.2.3}/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
@@ -1204,7 +1381,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 +1435,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 +1459,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 +1649,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 +1675,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 +1713,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

{flowent-0.2.2 → flowent-0.2.3}/src/flowent/permissions.py

@@ -12,6 +12,7 @@ from flowent.approval import (
 )
 from flowent.patch import affected_paths
 from flowent.sandbox import SandboxError, SandboxRunner, path_is_within
+from flowent.shell import shell_invocation
 from flowent.tools import (
     ToolContext,
     ToolResult,
@@ -290,10 +291,11 @@ async def shell_command_with_writable_paths(
 ) -> ToolResult:
     command = str(arguments["command"])
     timeout_seconds = number_argument(arguments, "timeout_seconds", 30)
+    invocation = shell_invocation(command)
     result = await SandboxRunner(
         cwd=context.cwd,
         writable_roots=writable_paths,
-    ).run_async(["/bin/sh", "-c", command], timeout_seconds=timeout_seconds)
+    ).run_async(invocation.args, env=invocation.env, timeout_seconds=timeout_seconds)
     ok = result.exit_code == 0
     content = result.stdout or result.stderr
     return ToolResult(
@@ -355,8 +357,9 @@ async def shell_command_without_sandbox(
 ) -> ToolResult:
     command = str(arguments["command"])
     timeout_seconds = number_argument(arguments, "timeout_seconds", 30)
+    invocation = shell_invocation(command)
     result = await SandboxRunner(cwd=context.cwd).run_unsandboxed_async(
-        ["/bin/sh", "-c", command], timeout_seconds=timeout_seconds
+        invocation.args, env=invocation.env, timeout_seconds=timeout_seconds
     )
     ok = result.exit_code == 0
     content = result.stdout or result.stderr

flowent-0.2.3/src/flowent/shell.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class ShellInvocation:
+    args: list[str]
+    env: dict[str, str]
+    shell: str
+
+
+def executable_path(path: Path) -> str | None:
+    if path.is_file() and os.access(path, os.X_OK):
+        return str(path.resolve(strict=False))
+    return None
+
+
+def executable_command_path(command: str) -> str | None:
+    resolved = shutil.which(command)
+    if resolved is None:
+        return None
+    return executable_path(Path(resolved))
+
+
+def shell_path(raw_shell: str) -> str | None:
+    raw_shell = raw_shell.strip()
+    if not raw_shell:
+        return None
+    expanded = Path(raw_shell).expanduser()
+    if expanded.is_absolute():
+        return executable_path(expanded)
+    return executable_command_path(raw_shell)
+
+
+def user_default_shell() -> str | None:
+    try:
+        import pwd
+    except ImportError:
+        return None
+
+    try:
+        shell = pwd.getpwuid(os.getuid()).pw_shell
+    except (AttributeError, KeyError, OSError):
+        return None
+    return shell_path(shell)
+
+
+def environment_shell() -> str | None:
+    return shell_path(os.environ.get("SHELL", ""))
+
+
+FALLBACK_SHELL_PATHS = {
+    "bash": [Path("/bin/bash"), Path("/usr/bin/bash")],
+    "sh": [Path("/bin/sh"), Path("/usr/bin/sh")],
+}
+
+
+def fallback_shell(command: str) -> str | None:
+    shell = executable_command_path(command)
+    if shell is not None:
+        return shell
+    for fallback in FALLBACK_SHELL_PATHS.get(command, []):
+        shell = executable_path(fallback)
+        if shell is not None:
+            return shell
+    return None
+
+
+def default_shell() -> str:
+    for shell in [user_default_shell(), environment_shell()]:
+        if shell is not None:
+            return shell
+    for command in ["bash", "sh"]:
+        shell = fallback_shell(command)
+        if shell is not None:
+            return shell
+    return "sh"
+
+
+def shell_invocation(command: str) -> ShellInvocation:
+    shell = default_shell()
+    return ShellInvocation(
+        args=[shell, "-c", command],
+        env={"SHELL": shell},
+        shell=shell,
+    )
+
+
+def shell_invocation_description() -> str:
+    return f"{default_shell()} -c"