flowent 0.3.3 → 0.3.5

package/README.md

@@ -4,7 +4,10 @@
 
 <p align="center">
   <a href="https://www.npmjs.com/package/flowent"><img src="https://img.shields.io/npm/v/flowent.svg?style=flat-square&label=npm" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/flowent"><img src="https://img.shields.io/npm/dm/flowent.svg?style=flat-square&label=npm" alt="npm monthly downloads" /></a>
   <a href="https://pypi.org/project/flowent/"><img src="https://img.shields.io/pypi/v/flowent.svg?style=flat-square&label=PyPI" alt="PyPI version" /></a>
+  <a href="https://pypi.org/project/flowent/"><img src="https://img.shields.io/pypi/dm/flowent.svg?style=flat-square&label=PyPI" alt="PyPI monthly downloads" /></a>
+  <br />
   <a href="https://github.com/ImFeH2/flowent/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/flowent.svg?style=flat-square&label=License" alt="License" /></a>
   <a href="https://github.com/ImFeH2/flowent/actions/workflows/ci.yml"><img src="https://github.com/ImFeH2/flowent/workflows/CI/badge.svg" alt="CI" /></a>
   <a href="https://github.com/ImFeH2/flowent/actions/workflows/release.yml"><img src="https://github.com/ImFeH2/flowent/workflows/Release/badge.svg" alt="Release" /></a>

package/backend/README.md

@@ -4,7 +4,10 @@
 
 <p align="center">
   <a href="https://www.npmjs.com/package/flowent"><img src="https://img.shields.io/npm/v/flowent.svg?style=flat-square&label=npm" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/flowent"><img src="https://img.shields.io/npm/dm/flowent.svg?style=flat-square&label=npm" alt="npm monthly downloads" /></a>
   <a href="https://pypi.org/project/flowent/"><img src="https://img.shields.io/pypi/v/flowent.svg?style=flat-square&label=PyPI" alt="PyPI version" /></a>
+  <a href="https://pypi.org/project/flowent/"><img src="https://img.shields.io/pypi/dm/flowent.svg?style=flat-square&label=PyPI" alt="PyPI monthly downloads" /></a>
+  <br />
   <a href="https://github.com/ImFeH2/flowent/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/flowent.svg?style=flat-square&label=License" alt="License" /></a>
   <a href="https://github.com/ImFeH2/flowent/actions/workflows/ci.yml"><img src="https://github.com/ImFeH2/flowent/workflows/CI/badge.svg" alt="CI" /></a>
   <a href="https://github.com/ImFeH2/flowent/actions/workflows/release.yml"><img src="https://github.com/ImFeH2/flowent/workflows/Release/badge.svg" alt="Release" /></a>

package/backend/pyproject.toml

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

package/backend/src/flowent/agent.py

@@ -47,7 +47,7 @@ Use tools deliberately:
 - 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 running a workflow and the user's current message contains one plain value to process, pass that content as the run_workflow input. When a workflow has multiple input nodes or the user provides separate values, use inputs with the exact input node ids from get_workflow.
 - 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.
@@ -120,6 +120,8 @@ async def run_agent_stream(
     *,
     completion: CompletionCallable | None,
     connection: ProviderConnection,
+    conversation_recorder: Callable[[Sequence[Mapping[str, object]]], None]
+    | None = None,
     cwd: Path,
     messages: Sequence[Mapping[str, object]],
     extra_tool_runner: Callable[[str, dict[str, object]], Awaitable[ToolResult | None]]
@@ -252,6 +254,9 @@ async def run_agent_stream(
         if not tool_calls:
             if not final_content and not final_thinking:
                 raise RuntimeError(EMPTY_MODEL_RESPONSE_ERROR)
+            conversation.append({"role": "assistant", "content": final_content})
+            if conversation_recorder is not None:
+                conversation_recorder([dict(message) for message in conversation])
             logger.info(
                 "Agent response completed id=%s rounds=%s content_length=%s thinking_length=%s decision=final_response",
                 assistant_id,

package/backend/src/flowent/agent_runtime.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+from collections.abc import (
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Mapping,
+    Sequence,
+)
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol
+
+from flowent.agent import AgentContextUpdate, AgentStreamEvent, run_agent_stream
+from flowent.approval import (
+    ApprovalReviewRequest,
+    ApprovalTranscriptEntry,
+    review_approval_request,
+)
+from flowent.llm import ChatMessage, CompletionCallable, ProviderConnection
+from flowent.permissions import run_tool_with_path_permissions
+from flowent.storage import StateStore
+from flowent.tools import ToolContext, ToolResult, tool_specs
+from flowent.workflow_tools import (
+    WorkflowAgentTools,
+    workflow_tool_specs,
+    workflow_tool_title,
+)
+
+if TYPE_CHECKING:
+    from flowent.workflow_service import WorkflowService
+
+
+class AgentMcpManager(Protocol):
+    def tool_specs(self) -> Sequence[Mapping[str, object]]: ...
+
+    def tool_title(self, name: str) -> str | None: ...
+
+    async def run_tool(
+        self, name: str, arguments: dict[str, object]
+    ) -> ToolResult | None: ...
+
+
+@dataclass(frozen=True)
+class AgentRunResult:
+    content: str
+    history: Sequence[Mapping[str, object]] = ()
+    thinking: str = ""
+
+
+class FlowentAgentRuntime:
+    def __init__(
+        self,
+        *,
+        chat_completion: CompletionCallable | None,
+        cwd: Path,
+        mcp_manager: AgentMcpManager | None,
+        store: StateStore,
+        workflow_service: WorkflowService | None,
+    ) -> None:
+        self.chat_completion = chat_completion
+        self.cwd = cwd
+        self.mcp_manager = mcp_manager
+        self.store = store
+        self.workflow_service = workflow_service
+
+    def extra_tool_specs(
+        self, *, include_workflow_tools: bool = True
+    ) -> list[Mapping[str, object]]:
+        return [
+            *(
+                workflow_tool_specs()
+                if include_workflow_tools and self.workflow_service is not None
+                else []
+            ),
+            *list(
+                self.mcp_manager.tool_specs() if self.mcp_manager is not None else []
+            ),
+        ]
+
+    def model_tool_specs(
+        self, *, include_workflow_tools: bool = True
+    ) -> list[Mapping[str, object]]:
+        return [
+            *tool_specs(),
+            *self.extra_tool_specs(include_workflow_tools=include_workflow_tools),
+        ]
+
+    def extra_tool_title(self, name: str) -> str | None:
+        return (
+            workflow_tool_title(name) if self.workflow_service is not None else None
+        ) or (
+            self.mcp_manager.tool_title(name) if self.mcp_manager is not None else None
+        )
+
+    def workflow_tools(self, workflow_depth: int = 0) -> WorkflowAgentTools | None:
+        if self.workflow_service is None:
+            return None
+        return WorkflowAgentTools(
+            self.workflow_service,
+            workflow_depth=workflow_depth,
+        )
+
+    async def run_extra_tool(
+        self,
+        name: str,
+        arguments: dict[str, object],
+        *,
+        include_workflow_tools: bool = True,
+        workflow_depth: int = 0,
+    ) -> ToolResult | None:
+        workflow_tools = (
+            self.workflow_tools(workflow_depth) if include_workflow_tools else None
+        )
+        if workflow_tools is not None:
+            workflow_result = await workflow_tools.run_tool(name, arguments)
+            if workflow_result is not None:
+                return workflow_result
+        if self.mcp_manager is None:
+            return None
+        return await self.mcp_manager.run_tool(name, arguments)
+
+    async def stream(
+        self,
+        *,
+        approval_transcript: Sequence[ApprovalTranscriptEntry] = (),
+        connection: ProviderConnection,
+        conversation_recorder: Callable[[Sequence[Mapping[str, object]]], None]
+        | None = None,
+        context_compactor: Callable[
+            [Sequence[Mapping[str, object]]], Awaitable[AgentContextUpdate | None]
+        ]
+        | None = None,
+        include_workflow_tools: bool = True,
+        messages: Sequence[ChatMessage | Mapping[str, object]],
+        user_request: str,
+        workflow_depth: int = 0,
+    ) -> AsyncIterator[AgentStreamEvent]:
+        transcript = list(approval_transcript)
+        request_messages = [
+            message.model_dump() if isinstance(message, ChatMessage) else dict(message)
+            for message in messages
+        ]
+
+        async def review_tool_approval(request: ApprovalReviewRequest):
+            return await review_approval_request(
+                connection,
+                request.model_copy(
+                    update={
+                        "transcript": transcript,
+                        "user_request": user_request,
+                    }
+                ),
+                completion=self.chat_completion,
+            )
+
+        async def tool_runner(
+            name: str,
+            arguments: dict[str, object],
+            context: ToolContext,
+        ) -> ToolResult:
+            return await run_tool_with_path_permissions(
+                name,
+                arguments,
+                context,
+                review_approval=review_tool_approval,
+                writable_paths=[
+                    Path(path.path) for path in self.store.read_writable_paths()
+                ],
+            )
+
+        async def extra_tool_runner(
+            name: str, arguments: dict[str, object]
+        ) -> ToolResult | None:
+            return await self.run_extra_tool(
+                name,
+                arguments,
+                include_workflow_tools=include_workflow_tools,
+                workflow_depth=workflow_depth,
+            )
+
+        async for event in run_agent_stream(
+            completion=self.chat_completion,
+            connection=connection,
+            conversation_recorder=conversation_recorder,
+            context_compactor=context_compactor,
+            cwd=self.cwd,
+            extra_tool_runner=extra_tool_runner,
+            extra_tool_specs=self.extra_tool_specs(
+                include_workflow_tools=include_workflow_tools
+            ),
+            extra_tool_title=self.extra_tool_title,
+            messages=request_messages,
+            tool_runner=tool_runner,
+        ):
+            yield event
+
+    async def complete(
+        self,
+        *,
+        approval_transcript: Sequence[ApprovalTranscriptEntry] = (),
+        connection: ProviderConnection,
+        include_workflow_tools: bool = True,
+        history_start_index: int = 0,
+        messages: Sequence[ChatMessage | Mapping[str, object]],
+        user_request: str,
+        workflow_depth: int = 0,
+    ) -> AgentRunResult:
+        recorded_conversation: list[Mapping[str, object]] = []
+
+        def record_conversation(
+            conversation: Sequence[Mapping[str, object]],
+        ) -> None:
+            recorded_conversation[:] = [dict(message) for message in conversation]
+
+        async for event in self.stream(
+            approval_transcript=approval_transcript,
+            connection=connection,
+            conversation_recorder=record_conversation,
+            include_workflow_tools=include_workflow_tools,
+            messages=messages,
+            user_request=user_request,
+            workflow_depth=workflow_depth,
+        ):
+            if event.event != "done":
+                continue
+            message = event.data.get("message")
+            if isinstance(message, Mapping):
+                return AgentRunResult(
+                    content=str(message.get("content") or ""),
+                    history=recorded_conversation[history_start_index:],
+                    thinking=str(message.get("thinking") or ""),
+                )
+        raise RuntimeError("Agent did not return a final response.")

package/backend/src/flowent/api_models.py

@@ -1,6 +1,6 @@
 from typing import Literal
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from flowent.llm import ProviderFormat
 from flowent.storage import StoredMessage, StoredWritablePath
@@ -65,6 +65,14 @@ class WorkspaceClearResponse(BaseModel):
     usage_info: TokenUsageInfo | None = None
 
 
+class WorkflowRunRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    input: str = ""
+    inputs: dict[str, str] = Field(default_factory=dict)
+    timer_id: str = ""
+
+
 class AboutResponse(BaseModel):
     model_config = ConfigDict(extra="forbid")
 

package/backend/src/flowent/app.py

@@ -60,6 +60,8 @@ def create_app(
     mcp_manager = McpManager(store=store, transport=mcp_transport)
     workflow_service = WorkflowService(
         chat_completion=chat_completion,
+        cwd=cwd,
+        mcp_manager=mcp_manager,
         store=store,
     )
 

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

@@ -1,9 +1,12 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import Body, FastAPI, HTTPException
 
+from flowent.api_models import WorkflowRunRequest
 from flowent.storage import StoredWorkflow
 from flowent.workflow_service import WorkflowService
 from flowent.workflows import WorkflowRunResponse
 
+OPTIONAL_WORKFLOW_RUN_BODY = Body(default=None)
+
 
 def register_workflow_routes(
     app: FastAPI,
@@ -23,9 +26,18 @@ def register_workflow_routes(
         return {"ok": True}
 
     @app.post("/api/workflows/{workflow_id}/run")
-    async def run_workflow(workflow_id: str) -> WorkflowRunResponse:
+    async def run_workflow(
+        workflow_id: str,
+        request: WorkflowRunRequest | None = OPTIONAL_WORKFLOW_RUN_BODY,
+    ) -> WorkflowRunResponse:
+        run_request = request or WorkflowRunRequest()
         try:
-            return await workflow_service.run_workflow(workflow_id)
+            return await workflow_service.run_workflow(
+                workflow_id,
+                default_input=run_request.input,
+                input_values=run_request.inputs,
+                timer_node_id=run_request.timer_id,
+            )
         except ValueError as error:
             status_code = 404 if str(error) == "Workflow not found." else 400
             raise HTTPException(status_code=status_code, detail=str(error)) from error

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

@@ -90,7 +90,7 @@ class StoredWorkflowNode(BaseModel):
     position: StoredWorkflowNodePosition = Field(
         default_factory=StoredWorkflowNodePosition
     )
-    type: Literal["input", "agent", "merge", "code", "output"]
+    type: Literal["input", "agent", "merge", "code", "timer", "output"]
 
 
 class StoredWorkflowEdge(BaseModel):

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

@@ -13,6 +13,14 @@ def migrate(connection: sqlite3.Connection) -> None:
             updated_at INTEGER NOT NULL DEFAULT (unixepoch())
         );
 
+        CREATE TABLE IF NOT EXISTS workflow_agent_histories (
+            workflow_id TEXT NOT NULL REFERENCES workflows(id) ON DELETE CASCADE,
+            node_id TEXT NOT NULL,
+            messages TEXT NOT NULL DEFAULT '[]',
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+            PRIMARY KEY (workflow_id, node_id)
+        );
+
         CREATE TABLE IF NOT EXISTS mcp_servers (
             id TEXT PRIMARY KEY,
             name TEXT NOT NULL,

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

@@ -1,5 +1,6 @@
 import json
 import sqlite3
+from collections.abc import Mapping
 from pathlib import Path
 
 from flowent.llm import ChatMessage, ReasoningEffort
@@ -172,6 +173,50 @@ class StateStore:
         with self.connect() as connection:
             return self._read_workflows(connection)
 
+    def read_workflow_agent_history(
+        self, workflow_id: str, node_id: str
+    ) -> list[dict[str, object]]:
+        with self.connect() as connection:
+            row = connection.execute(
+                """
+                SELECT messages
+                FROM workflow_agent_histories
+                WHERE workflow_id = ? AND node_id = ?
+                """,
+                (workflow_id, node_id),
+            ).fetchone()
+        if row is None:
+            return []
+        return workflow_agent_history_messages(row["messages"])
+
+    def save_workflow_agent_history(
+        self,
+        workflow_id: str,
+        node_id: str,
+        messages: list[Mapping[str, object]],
+    ) -> list[dict[str, object]]:
+        stored_messages = [dict(message) for message in messages]
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO workflow_agent_histories (
+                    workflow_id,
+                    node_id,
+                    messages
+                )
+                VALUES (?, ?, ?)
+                ON CONFLICT(workflow_id, node_id) DO UPDATE SET
+                    messages = excluded.messages,
+                    updated_at = unixepoch()
+                """,
+                (
+                    workflow_id,
+                    node_id,
+                    json.dumps(stored_messages, ensure_ascii=False),
+                ),
+            )
+        return stored_messages
+
     def save_workflow(self, workflow: StoredWorkflow) -> StoredWorkflow:
         with self.connect() as connection:
             connection.execute(
@@ -1017,3 +1062,15 @@ class StateStore:
                 """
             )
         ]
+
+
+def workflow_agent_history_messages(value: str) -> list[dict[str, object]]:
+    parsed = json.loads(value or "[]")
+    if not isinstance(parsed, list):
+        raise ValueError("Workflow agent history must be a list.")
+    messages: list[dict[str, object]] = []
+    for item in parsed:
+        if not isinstance(item, dict):
+            raise ValueError("Workflow agent history messages must be objects.")
+        messages.append(dict(item))
+    return messages