flowent 0.3.0 → 0.3.2

package/backend/pyproject.toml

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

package/backend/src/flowent/agent.py

@@ -25,6 +25,8 @@ from flowent.tools import (
     new_tool_item,
     parse_tool_arguments,
     run_tool_async,
+    text_tool_result,
+    tool_result_model_content,
     tool_specs,
 )
 
@@ -277,7 +279,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 +299,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:
@@ -314,10 +320,12 @@ async def run_agent_stream(
                     if extra_tool_runner is not None
                     else None
                 )
-                result = extra_result if isinstance(extra_result, ToolResult) else None
-                if result is None:
+                tool_result: ToolResult | None = (
+                    extra_result if isinstance(extra_result, ToolResult) else None
+                )
+                if tool_result is None:
                     context = ToolContext(cwd=cwd, web_searcher=web_searcher)
-                    result = await (
+                    tool_result = await (
                         tool_runner(
                             tool_call.name,
                             arguments,
@@ -330,27 +338,26 @@ async def run_agent_stream(
                             context,
                         )
                     )
-                result_content = result.content
+                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/api_models.py

@@ -19,6 +19,18 @@ class ProviderModelsResponse(BaseModel):
     models: list[str]
 
 
+class ProviderModelsFailureResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    code: Literal[
+        "connection_failed",
+        "access_denied",
+        "rate_limited",
+        "provider_unavailable",
+        "request_failed",
+    ]
+
+
 class WorkspaceMessagesRequest(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -35,8 +47,8 @@ class WorkspaceMessageEditRequest(BaseModel):
 class WorkspaceMessageEditResponse(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
+    is_responding: bool = False
     messages: list[StoredMessage]
-    run_id: str | None = None
 
 
 class WorkspaceRespondRequest(BaseModel):
@@ -46,16 +58,9 @@ class WorkspaceRespondRequest(BaseModel):
     message_id: str | None = None
 
 
-class WorkspaceRunResponse(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    run_id: str
-
-
 class WorkspaceClearResponse(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    active_run_id: str | None = None
     messages: list[StoredMessage]
     usage_info: TokenUsageInfo | None = None
 

package/backend/src/flowent/llm.py

@@ -85,6 +85,20 @@ class LLMStreamError(RuntimeError):
     pass
 
 
+class ProviderModelFetchFailure(StrEnum):
+    CONNECTION_FAILED = "connection_failed"
+    ACCESS_DENIED = "access_denied"
+    RATE_LIMITED = "rate_limited"
+    PROVIDER_UNAVAILABLE = "provider_unavailable"
+    REQUEST_FAILED = "request_failed"
+
+
+class ProviderModelFetchError(RuntimeError):
+    def __init__(self, failure: ProviderModelFetchFailure) -> None:
+        super().__init__(failure.value)
+        self.failure = failure
+
+
 async def wait_before_llm_retry(attempt_number: int) -> None:
     await asyncio.sleep(LLM_RETRY_BASE_DELAY_SECONDS * attempt_number)
 
@@ -248,6 +262,31 @@ def unique_model_names(provider: ProviderFormat, models: Sequence[str]) -> list[
     return normalized_models
 
 
+def classify_provider_model_fetch_failure(
+    exception: Exception,
+) -> ProviderModelFetchFailure:
+    try:
+        import litellm
+    except Exception:
+        return ProviderModelFetchFailure.REQUEST_FAILED
+
+    if isinstance(exception, (litellm.APIConnectionError, litellm.Timeout)):
+        return ProviderModelFetchFailure.CONNECTION_FAILED
+    if isinstance(
+        exception, (litellm.AuthenticationError, litellm.PermissionDeniedError)
+    ):
+        return ProviderModelFetchFailure.ACCESS_DENIED
+    if isinstance(exception, litellm.RateLimitError):
+        return ProviderModelFetchFailure.RATE_LIMITED
+    if isinstance(
+        exception, (litellm.ServiceUnavailableError, litellm.InternalServerError)
+    ):
+        return ProviderModelFetchFailure.PROVIDER_UNAVAILABLE
+    if isinstance(exception, (ConnectionError, TimeoutError)):
+        return ProviderModelFetchFailure.CONNECTION_FAILED
+    return ProviderModelFetchFailure.REQUEST_FAILED
+
+
 def list_provider_models(
     *,
     provider: ProviderFormat,
@@ -261,12 +300,17 @@ def list_provider_models(
         configure_litellm_logging()
         model_lister = get_valid_models
 
-    models = model_lister(
-        api_base=normalize_provider_base_url(provider, base_url),
-        api_key=secret_reference,
-        check_provider_endpoint=True,
-        custom_llm_provider=provider_litellm_name(provider),
-    )
+    try:
+        models = model_lister(
+            api_base=normalize_provider_base_url(provider, base_url),
+            api_key=secret_reference,
+            check_provider_endpoint=True,
+            custom_llm_provider=provider_litellm_name(provider),
+        )
+    except Exception as exc:
+        raise ProviderModelFetchError(
+            classify_provider_model_fetch_failure(exc)
+        ) from exc
     return unique_model_names(provider, models)
 
 

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

@@ -16,10 +16,13 @@ from flowent.shell import shell_invocation
 from flowent.tools import (
     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 +69,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 +133,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 +201,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 +215,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 +252,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 +276,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),
     )
 
@@ -297,27 +310,25 @@ async def shell_command_with_writable_paths(
         writable_roots=writable_paths,
     ).run_async(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}",
     )
 
 
 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 +356,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 +381,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 +416,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/providers.py

@@ -1,9 +1,25 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException, status
 
-from flowent.api_models import ProviderModelsRequest, ProviderModelsResponse
-from flowent.llm import list_provider_models
+from flowent.api_models import (
+    ProviderModelsFailureResponse,
+    ProviderModelsRequest,
+    ProviderModelsResponse,
+)
+from flowent.llm import (
+    ProviderModelFetchError,
+    ProviderModelFetchFailure,
+    list_provider_models,
+)
 from flowent.storage import StateStore, StoredProvider, StoredSettings
 
+PROVIDER_MODEL_FAILURE_STATUS: dict[ProviderModelFetchFailure, int] = {
+    ProviderModelFetchFailure.CONNECTION_FAILED: status.HTTP_502_BAD_GATEWAY,
+    ProviderModelFetchFailure.ACCESS_DENIED: status.HTTP_403_FORBIDDEN,
+    ProviderModelFetchFailure.RATE_LIMITED: status.HTTP_429_TOO_MANY_REQUESTS,
+    ProviderModelFetchFailure.PROVIDER_UNAVAILABLE: status.HTTP_503_SERVICE_UNAVAILABLE,
+    ProviderModelFetchFailure.REQUEST_FAILED: status.HTTP_400_BAD_REQUEST,
+}
+
 
 def register_provider_routes(app: FastAPI, *, store: StateStore) -> None:
     @app.post("/api/providers")
@@ -17,13 +33,20 @@ def register_provider_routes(app: FastAPI, *, store: StateStore) -> None:
 
     @app.post("/api/providers/models")
     async def provider_models(request: ProviderModelsRequest) -> ProviderModelsResponse:
-        return ProviderModelsResponse(
-            models=list_provider_models(
-                base_url=request.base_url,
-                provider=request.provider,
-                secret_reference=request.secret_reference,
-            ),
-        )
+        try:
+            return ProviderModelsResponse(
+                models=list_provider_models(
+                    base_url=request.base_url,
+                    provider=request.provider,
+                    secret_reference=request.secret_reference,
+                ),
+            )
+        except ProviderModelFetchError as exc:
+            detail = ProviderModelsFailureResponse(code=exc.failure.value)
+            raise HTTPException(
+                detail=detail.model_dump(),
+                status_code=PROVIDER_MODEL_FAILURE_STATUS[exc.failure],
+            ) from exc
 
     @app.put("/api/settings")
     async def save_settings(settings: StoredSettings) -> StoredSettings:

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

@@ -28,14 +28,13 @@ def register_system_routes(
     @app.get("/api/state")
     async def app_state() -> StoredState:
         state = state_with_current_model_context_window(store.read_state())
-        active_run = runtime.active_run()
+        active_response = runtime.current_response()
         update: dict[str, object] = {
-            "active_run_event_index": active_run.latest_event_index
-            if active_run
+            "is_responding": active_response is not None
+            and not active_response.is_done,
+            "response_event_index": active_response.latest_event_index
+            if active_response
             else 0,
-            "active_run_id": active_run.id
-            if active_run and not active_run.is_done
-            else None,
             "mcp_servers": mcp_manager.servers_with_status(state.mcp_servers),
             "skills": discover_skills(cwd, store),
         }

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

@@ -9,7 +9,6 @@ from flowent.api_models import (
     WorkspaceMessageEditResponse,
     WorkspaceMessagesRequest,
     WorkspaceRespondRequest,
-    WorkspaceRunResponse,
 )
 from flowent.logging import TRACE_LEVEL
 from flowent.storage import StateStore
@@ -42,45 +41,54 @@ def register_workspace_routes(
             len(request.content),
         )
         logger.log(TRACE_LEVEL, "Workspace edited user content=%r", request.content)
-        messages, run = runtime.edit_message(
+        messages, response = runtime.edit_message(
             message_id,
             action=request.action,
             content=request.content,
         )
         return WorkspaceMessageEditResponse(
+            is_responding=response is not None,
+            messages=messages,
+        )
+
+    @app.post("/api/workspace/messages/{message_id}/errors/{error_id}/retry")
+    async def retry_workspace_error(
+        message_id: str,
+        error_id: str,
+    ) -> WorkspaceMessageEditResponse:
+        logger.info(
+            "Workspace error retry requested message_id=%s error_id=%s",
+            message_id,
+            error_id,
+        )
+        messages, response = runtime.retry_error(
+            message_id,
+            error_id=error_id,
+        )
+        return WorkspaceMessageEditResponse(
+            is_responding=response is not None,
             messages=messages,
-            run_id=run.id if run else None,
         )
 
     @app.post("/api/workspace/clear")
     async def clear_workspace() -> WorkspaceClearResponse:
         messages = runtime.clear()
-        await runtime.notify_cleared_runs()
+        await runtime.notify_cleared_response()
         return WorkspaceClearResponse(messages=messages)
 
-    @app.post("/api/workspace/runs")
-    async def start_workspace_run(
-        request: WorkspaceRespondRequest,
-    ) -> WorkspaceRunResponse:
-        logger.info("Workspace run requested content_length=%s", len(request.content))
-        logger.log(TRACE_LEVEL, "Workspace user content=%r", request.content)
-        run = runtime.create_run(request.content, message_id=request.message_id)
-        return WorkspaceRunResponse(run_id=run.id)
-
-    @app.get("/api/workspace/runs/{run_id}/stream")
-    async def stream_workspace_run(
-        run_id: str,
+    @app.get("/api/workspace/stream")
+    async def stream_workspace_response(
         after: int = Query(default=0, ge=0),
     ) -> StreamingResponse:
-        run = runtime.run_by_id(run_id)
+        response = runtime.stream_current_response()
         return StreamingResponse(
-            runtime.run_stream(run, after),
+            runtime.response_stream(response, after),
             media_type="text/event-stream",
         )
 
-    @app.post("/api/workspace/runs/{run_id}/stop")
-    async def stop_workspace_run(run_id: str) -> dict[str, bool]:
-        runtime.stop_run(run_id)
+    @app.post("/api/workspace/stop")
+    async def stop_workspace_response() -> dict[str, bool]:
+        runtime.stop_response()
         return {"ok": True}
 
     @app.post("/api/workspace/compact", response_class=StreamingResponse)
@@ -98,8 +106,10 @@ def register_workspace_routes(
             "Workspace response requested content_length=%s", len(request.content)
         )
         logger.log(TRACE_LEVEL, "Workspace user content=%r", request.content)
-        run = runtime.create_run(request.content, message_id=request.message_id)
+        response = runtime.start_response(
+            request.content, message_id=request.message_id
+        )
         return StreamingResponse(
-            runtime.run_stream(run, include_snapshots=False),
+            runtime.response_stream(response, include_snapshots=False),
             media_type="text/event-stream",
         )

package/backend/src/flowent/state/models.py

@@ -151,8 +151,7 @@ class StoredToolItem(BaseModel):
     status: str
     title: str
     arguments: dict[str, object] | None = None
-    content: str | None = None
-    data: dict[str, object] | None = None
+    result: dict[str, object] | None = None
 
 
 class StoredThinkingOutputItem(BaseModel):
@@ -217,6 +216,7 @@ class StoredMessage(BaseModel):
     status: str = Field(
         default="completed", exclude_if=lambda value: value == "completed"
     )
+    summary: str = Field(default="", exclude_if=lambda value: value == "")
     thinking: str = Field(default="", exclude_if=lambda value: value == "")
     tools: list[StoredToolItem] = Field(default_factory=list)
     usage_info: TokenUsageInfo | None = Field(
@@ -241,8 +241,8 @@ class StoredCompactionCheckpoint(BaseModel):
 class StoredState(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    active_run_event_index: int = 0
-    active_run_id: str | None = None
+    is_responding: bool = False
+    response_event_index: int = 0
     is_compacting: bool = False
     mcp_servers: list[StoredMcpServer]
     messages: list[StoredMessage]