flowent 0.3.1 → 0.3.3

package/backend/pyproject.toml

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

package/backend/src/flowent/agent.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
+from typing import cast
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict
@@ -25,6 +27,8 @@ from flowent.tools import (
     new_tool_item,
     parse_tool_arguments,
     run_tool_async,
+    text_tool_result,
+    tool_result_model_content,
     tool_specs,
 )
 
@@ -42,6 +46,10 @@ Use tools deliberately:
 - Apply structured patches for file edits.
 - Run shell commands for diagnostics, builds, tests, and operations that require the local environment.
 - When a shell command needs to write outside the current workspace, declare each needed writable directory with sandbox_permissions set to with_additional_permissions and additional_permissions.file_system.write. Flowent reviews elevated permissions automatically, so keep the requested paths specific and tied to the task.
+- Use workflow tools when the user asks to view, inspect, run, create, or modify saved workflows. List workflows first when you need the workflow id. Read a workflow before modifying it.
+- When running a workflow and the user's current message contains the content to process, pass that content as the run_workflow input. Use inputs only when you need to target specific input node ids.
+- When creating or updating a workflow, save a complete workflow object with valid node ids and edges. If saving fails, use the validation error as context and explain what needs to change.
+- Do not delete workflows. If the user asks to delete a workflow, say that you cannot do that directly.
 - Search the web only when current external information is needed.
 - Update the plan when a task has multiple meaningful steps.
 
@@ -277,7 +285,12 @@ async def run_agent_stream(
                 arguments = parse_tool_arguments(tool_call.arguments)
             except Exception as error:
                 arguments = {}
-                result_content = str(error)
+                result = ToolResult(
+                    result=text_tool_result(str(error)),
+                    ok=False,
+                    title=tool_call.name or "Tool failed",
+                )
+                result_content = tool_result_model_content(result)
                 tool_item = new_tool_item(tool_call.name, arguments)
                 logger.debug("Tool call argument parse failed name=%s", tool_call.name)
                 logger.log(TRACE_LEVEL, "Tool start item=%r", tool_item)
@@ -292,10 +305,9 @@ async def run_agent_stream(
                     event="tool_error",
                     data={
                         "id": tool_item["id"],
-                        "content": result_content,
-                        "data": {},
+                        "result": result.result,
                         "status": "failed",
-                        "title": tool_call.name or "Tool failed",
+                        "title": result.title,
                     },
                 )
             else:
@@ -309,15 +321,35 @@ async def run_agent_stream(
                 )
                 logger.log(TRACE_LEVEL, "Tool start item=%r", tool_item)
                 yield AgentStreamEvent(event="tool_start", data={"tool": tool_item})
+                tool_event_queue: asyncio.Queue[dict[str, object]] = asyncio.Queue()
+
+                async def emit_tool_event(
+                    data: dict[str, object],
+                    *,
+                    queue: asyncio.Queue[dict[str, object]] = tool_event_queue,
+                    tool_id: str = str(tool_item["id"]),
+                ) -> None:
+                    yield_data = {
+                        "id": tool_id,
+                        **data,
+                    }
+                    await queue.put(yield_data)
+
                 extra_result = (
                     await extra_tool_runner(tool_call.name, arguments)
                     if extra_tool_runner is not None
                     else None
                 )
-                result = extra_result if isinstance(extra_result, ToolResult) else None
-                if result is None:
-                    context = ToolContext(cwd=cwd, web_searcher=web_searcher)
-                    result = await (
+                tool_result: ToolResult | None = (
+                    extra_result if isinstance(extra_result, ToolResult) else None
+                )
+                if tool_result is None:
+                    context = ToolContext(
+                        cwd=cwd,
+                        emit_event=emit_tool_event,
+                        web_searcher=web_searcher,
+                    )
+                    tool_task: asyncio.Future[ToolResult] = asyncio.ensure_future(
                         tool_runner(
                             tool_call.name,
                             arguments,
@@ -330,27 +362,61 @@ async def run_agent_stream(
                             context,
                         )
                     )
-                result_content = result.content
+                    pending_event_task: asyncio.Future[dict[str, object]] | None = None
+                    try:
+                        while True:
+                            if pending_event_task is None:
+                                pending_event_task = asyncio.create_task(
+                                    tool_event_queue.get()
+                                )
+                            done, _ = await asyncio.wait(
+                                {
+                                    cast(asyncio.Future[object], tool_task),
+                                    cast(asyncio.Future[object], pending_event_task),
+                                },
+                                return_when=asyncio.FIRST_COMPLETED,
+                            )
+                            if pending_event_task in done:
+                                yield AgentStreamEvent(
+                                    event="tool_update",
+                                    data=pending_event_task.result(),
+                                )
+                                pending_event_task = None
+                            if tool_task in done:
+                                if pending_event_task is not None:
+                                    pending_event_task.cancel()
+                                break
+                    except asyncio.CancelledError:
+                        tool_task.cancel()
+                        if pending_event_task is not None:
+                            pending_event_task.cancel()
+                        raise
+                    tool_result = await tool_task
+                    while not tool_event_queue.empty():
+                        yield AgentStreamEvent(
+                            event="tool_update",
+                            data=tool_event_queue.get_nowait(),
+                        )
+                result_content = tool_result_model_content(tool_result)
                 logger.debug(
                     "Tool call finished name=%s id=%s ok=%s",
                     tool_call.name,
                     tool_item["id"],
-                    result.ok,
+                    tool_result.ok,
                 )
                 logger.log(
                     TRACE_LEVEL,
                     "Tool result id=%s result=%r",
                     tool_item["id"],
-                    result.model_dump(),
+                    tool_result.model_dump(),
                 )
                 yield AgentStreamEvent(
-                    event="tool_done" if result.ok else "tool_error",
+                    event="tool_done" if tool_result.ok else "tool_error",
                     data={
                         "id": tool_item["id"],
-                        "content": result.content,
-                        "data": result.data,
-                        "status": "success" if result.ok else "failed",
-                        "title": result.title,
+                        "result": tool_result.result,
+                        "status": "success" if tool_result.ok else "failed",
+                        "title": tool_result.title,
                     },
                 )
             conversation.append(tool_result_message(tool_call_id, result_content))

package/backend/src/flowent/app.py

@@ -23,6 +23,7 @@ from flowent.routes.workspace import register_workspace_routes
 from flowent.sandbox import ensure_sandbox_available
 from flowent.storage import StateStore
 from flowent.system_tools import ensure_ripgrep_available
+from flowent.workflow_service import WorkflowService
 from flowent.workspace.runtime import WorkspaceRuntime
 
 logger = logging.getLogger("flowent.app")
@@ -57,6 +58,10 @@ def create_app(
     store = StateStore()
     compact_provider = LocalSummaryCompactProvider()
     mcp_manager = McpManager(store=store, transport=mcp_transport)
+    workflow_service = WorkflowService(
+        chat_completion=chat_completion,
+        store=store,
+    )
 
     static_dir = frontend_static_directory().resolve(strict=False)
     logger.debug("Flowent app created serve_frontend=%s", serve_frontend)
@@ -69,6 +74,7 @@ def create_app(
         cwd=cwd,
         mcp_manager=mcp_manager,
         store=store,
+        workflow_service=workflow_service,
     )
 
     telegram_bot_manager = TelegramBotManager(
@@ -121,8 +127,7 @@ def create_app(
     )
     register_workflow_routes(
         app,
-        chat_completion=chat_completion,
-        store=store,
+        workflow_service=workflow_service,
     )
     register_permission_routes(app, cwd=cwd, store=store)
     register_workspace_routes(app, runtime=runtime, store=store)

package/backend/src/flowent/mcp.py

@@ -662,11 +662,12 @@ class McpManager:
         content = mcp_result_content(result)
         server_name = self._server_names.get(server_id, server_id)
         return ToolResult(
-            content=content,
-            data={
+            result={
+                "type": "mcp",
+                "output": content,
                 "server": server_name,
                 "tool": tool_name,
-                "result": result,
+                "raw_result": result,
             },
             ok=not mcp_result_is_error(result),
             title=f"Calling {server_name}.{tool_name}",

package/backend/src/flowent/permissions.py

@@ -14,12 +14,16 @@ 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 (
+    CommandOutputCollector,
     ToolContext,
     ToolResult,
+    command_tool_result,
     number_argument,
     patch_title_from_result,
     run_tool_async,
+    text_tool_result,
     tool_failure_content,
+    tool_result_model_content,
 )
 
 SANDBOX_WITH_ADDITIONAL_PERMISSIONS = "with_additional_permissions"
@@ -66,7 +70,7 @@ def validate_additional_permissions(arguments: dict[str, object]) -> ToolResult
         return None
     if sandbox_permissions != SANDBOX_WITH_ADDITIONAL_PERMISSIONS:
         return ToolResult(
-            content=(
+            result=text_tool_result(
                 "additional_permissions requires sandbox_permissions to be "
                 "with_additional_permissions."
             ),
@@ -130,8 +134,10 @@ async def review_missing_write_paths(
         return (
             effective_paths,
             ToolResult(
-                content=approval_denial_content(decision),
-                data=review_data,
+                result=text_tool_result(
+                    approval_denial_content(decision),
+                    **review_data,
+                ),
                 ok=False,
                 title="Denied by reviewer",
             ),
@@ -196,7 +202,7 @@ async def run_shell_command_with_permissions(
         arguments, context, effective_paths
     )
     if approval_data is not None:
-        result = tool_result_with_data(result, approval_data)
+        result = tool_result_with_fields(result, approval_data)
     if result.ok or not is_likely_sandbox_denied_result(result):
         return result
     review_request = ApprovalReviewRequest(
@@ -210,13 +216,16 @@ async def run_shell_command_with_permissions(
     review_data = approval_result_data(review_request, decision)
     if decision.decision == "denied":
         return ToolResult(
-            content=approval_denial_content(decision),
-            data={**result.data, **review_data},
+            result=text_tool_result(
+                approval_denial_content(decision),
+                previous_result=result.result,
+                **review_data,
+            ),
             ok=False,
             title="Denied by reviewer",
         )
     retry_result = await shell_command_without_sandbox(arguments, context)
-    return tool_result_with_data(retry_result, review_data)
+    return tool_result_with_fields(retry_result, review_data)
 
 
 async def run_apply_patch_with_permissions(
@@ -244,7 +253,7 @@ async def run_apply_patch_with_permissions(
 
     result = await apply_patch_with_writable_paths(arguments, context, effective_paths)
     if approval_data is not None:
-        result = tool_result_with_data(result, approval_data)
+        result = tool_result_with_fields(result, approval_data)
     return result
 
 
@@ -268,18 +277,23 @@ async def apply_patch_with_writable_paths(
             input_text=patch,
         )
     except SandboxError as error:
-        return ToolResult(content=str(error), ok=False, title="Edit failed")
+        return ToolResult(
+            result=text_tool_result(str(error)), ok=False, title="Edit failed"
+        )
 
     if result.exit_code != 0:
         return ToolResult(
-            content=tool_failure_content(result),
+            result=text_tool_result(tool_failure_content(result)),
             ok=False,
             title="Edit failed",
         )
     data = json.loads(result.stdout or "{}")
     return ToolResult(
-        content=result.stdout,
-        data=data if isinstance(data, dict) else {},
+        result={
+            "type": "patch",
+            "output": result.stdout,
+            **(data if isinstance(data, dict) else {}),
+        },
         title=patch_title_from_result(data),
     )
 
@@ -292,32 +306,38 @@ async def shell_command_with_writable_paths(
     command = str(arguments["command"])
     timeout_seconds = number_argument(arguments, "timeout_seconds", 30)
     invocation = shell_invocation(command)
+    collector = CommandOutputCollector(command, context.emit_event)
     result = await SandboxRunner(
         cwd=context.cwd,
         writable_roots=writable_paths,
-    ).run_async(invocation.args, env=invocation.env, timeout_seconds=timeout_seconds)
+    ).run_async(
+        invocation.args,
+        env=invocation.env,
+        on_stderr=collector.append_stderr,
+        on_stdout=collector.append_stdout,
+        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,
-        },
+        result=command_tool_result(
+            command=command,
+            exit_code=result.exit_code,
+            output_chunks=collector.output_chunks,
+            stderr=result.stderr or collector.stderr,
+            stdout=result.stdout or collector.stdout,
+        ),
         ok=ok,
         title=f"Ran {command}",
     )
 
 
 def is_likely_sandbox_denied_result(result: ToolResult) -> bool:
-    data = result.data
-    exit_code = int_result_field(data.get("exit_code"))
+    payload = result.result
+    exit_code = int_result_field(payload.get("exit_code"))
     if exit_code == 0:
         return False
     output = "\n".join(
-        str(data.get(name, "") or "") for name in ["stderr", "stdout"]
+        str(payload.get(name, "") or "") for name in ["stderr", "stdout", "output"]
     ).lower()
     return any(
         keyword in output
@@ -345,13 +365,17 @@ def int_result_field(value: object) -> int:
 
 
 def tool_failure_text(result: ToolResult) -> str:
-    stderr = str(result.data.get("stderr", "") or "").strip()
-    stdout = str(result.data.get("stdout", "") or "").strip()
-    content = result.content.strip()
+    payload = result.result
+    stderr = str(payload.get("stderr", "") or "").strip()
+    stdout = str(payload.get("stdout", "") or "").strip()
     parts: list[str] = []
-    for part in [stderr, stdout, content]:
+    for part in [stderr, stdout]:
         if part and part not in parts:
             parts.append(part)
+    if not parts:
+        content = tool_result_model_content(result).strip()
+        if content:
+            parts.append(content)
     return "\n".join(parts)
 
 
@@ -366,15 +390,13 @@ async def shell_command_without_sandbox(
         invocation.args, env=invocation.env, 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,
-        },
+        result=command_tool_result(
+            command=command,
+            exit_code=result.exit_code,
+            stderr=result.stderr,
+            stdout=result.stdout,
+        ),
         ok=ok,
         title=f"Ran {command}",
     )
@@ -403,7 +425,7 @@ def approval_result_data(
     }
 
 
-def tool_result_with_data(
-    result: ToolResult, extra_data: dict[str, object]
+def tool_result_with_fields(
+    result: ToolResult, extra_fields: dict[str, object]
 ) -> ToolResult:
-    return result.model_copy(update={"data": {**result.data, **extra_data}})
+    return result.model_copy(update={"result": {**result.result, **extra_fields}})

package/backend/src/flowent/routes/workflow_routes.py

@@ -1,63 +1,31 @@
 from fastapi import FastAPI, HTTPException
 
-from flowent.llm import CompletionCallable
-from flowent.provider_connections import selected_connection
-from flowent.storage import StateStore, StoredWorkflow
-from flowent.workflows import (
-    WorkflowRunResponse,
-    run_workflow_definition,
-    validate_workflow_draft,
-    workflow_requires_connection,
-)
+from flowent.storage import StoredWorkflow
+from flowent.workflow_service import WorkflowService
+from flowent.workflows import WorkflowRunResponse
 
 
 def register_workflow_routes(
     app: FastAPI,
     *,
-    chat_completion: CompletionCallable | None,
-    store: StateStore,
+    workflow_service: WorkflowService,
 ) -> None:
     @app.put("/api/workflows")
     async def save_workflow(workflow: StoredWorkflow) -> StoredWorkflow:
         try:
-            return store.save_workflow(
-                validate_workflow_draft(
-                    workflow.model_copy(
-                        update={"name": workflow.name.strip() or "Untitled Workflow"}
-                    )
-                )
-            )
+            return workflow_service.save_workflow(workflow)
         except ValueError as error:
             raise HTTPException(status_code=400, detail=str(error)) from error
 
     @app.delete("/api/workflows/{workflow_id}")
     async def delete_workflow(workflow_id: str) -> dict[str, bool]:
-        store.delete_workflow(workflow_id)
+        workflow_service.store.delete_workflow(workflow_id)
         return {"ok": True}
 
     @app.post("/api/workflows/{workflow_id}/run")
     async def run_workflow(workflow_id: str) -> WorkflowRunResponse:
-        workflow = next(
-            (
-                current_workflow
-                for current_workflow in store.read_workflows()
-                if current_workflow.id == workflow_id
-            ),
-            None,
-        )
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found.")
         try:
-            connection = (
-                selected_connection(store.read_state())
-                if workflow_requires_connection(workflow.definition)
-                else None
-            )
-            return await run_workflow_definition(
-                completion=chat_completion,
-                connection=connection,
-                definition=workflow.definition,
-                workflow_id=workflow.id,
-            )
+            return await workflow_service.run_workflow(workflow_id)
         except ValueError as error:
-            raise HTTPException(status_code=400, detail=str(error)) from error
+            status_code = 404 if str(error) == "Workflow not found." else 400
+            raise HTTPException(status_code=status_code, detail=str(error)) from error