flowent 0.3.4 → 0.3.6

package/backend/pyproject.toml

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

package/backend/src/flowent/agent.py

@@ -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

@@ -44,6 +44,7 @@ class AgentMcpManager(Protocol):
 @dataclass(frozen=True)
 class AgentRunResult:
     content: str
+    history: Sequence[Mapping[str, object]] = ()
     thinking: str = ""
 
 
@@ -124,6 +125,8 @@ class FlowentAgentRuntime:
         *,
         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]
         ]
@@ -179,6 +182,7 @@ class FlowentAgentRuntime:
         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,
@@ -197,13 +201,22 @@ class FlowentAgentRuntime:
         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,
@@ -215,6 +228,7 @@ class FlowentAgentRuntime:
             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/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