flowent 0.3.2 → 0.3.4

package/backend/src/flowent/workflows.py

@@ -1,16 +1,19 @@
+from __future__ import annotations
+
 import json
 import re
+import sys
+import tempfile
 from collections import defaultdict, deque
 from collections.abc import Mapping
+from pathlib import Path
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from flowent.llm import (
-    ChatMessage,
-    CompletionCallable,
-    ProviderConnection,
-    complete_chat,
-)
+from flowent.context import runtime_context_messages
+from flowent.llm import ProviderConnection
+from flowent.sandbox import SandboxRunner
 from flowent.storage import (
     StoredWorkflow,
     StoredWorkflowDefinition,
@@ -18,6 +21,9 @@ from flowent.storage import (
     StoredWorkflowNode,
 )
 
+if TYPE_CHECKING:
+    from flowent.agent_runtime import FlowentAgentRuntime
+
 
 class WorkflowNodeRunResult(BaseModel):
     model_config = ConfigDict(extra="forbid")
@@ -37,7 +43,39 @@ class WorkflowRunResponse(BaseModel):
     workflow_id: str
 
 
+class WorkflowRunRequestValues(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    default_input: str = ""
+    input_values: dict[str, str] = Field(default_factory=dict)
+
+
 PLACEHOLDER_PATTERN = re.compile(r"\{\{\s*([A-Za-z0-9_.-]+)\.output\s*\}\}")
+PYTHON_CODE_RUNNER = r"""
+import contextlib
+import io
+import json
+import sys
+
+payload = json.loads(sys.stdin.read() or "{}")
+namespace = {
+    "input": payload.get("input", ""),
+    "inputs": payload.get("inputs", []),
+    "output": "",
+}
+stdout = io.StringIO()
+with contextlib.redirect_stdout(stdout):
+    exec(str(payload.get("code", "")), namespace)
+captured = stdout.getvalue()
+result = namespace.get("output")
+if result is None:
+    result = ""
+if result == "" and captured:
+    result = captured.rstrip("\n")
+if not isinstance(result, str):
+    result = json.dumps(result, ensure_ascii=False)
+print(result, end="")
+"""
 
 
 def validate_workflow(workflow: StoredWorkflow) -> StoredWorkflow:
@@ -77,8 +115,8 @@ def validate_workflow_definition(definition: StoredWorkflowDefinition) -> list[s
         raise ValueError("Workflow node ids must not be empty.")
     if len(set(node_ids)) != len(node_ids):
         raise ValueError("Workflow node ids must be unique.")
-    if not any(node.type == "input" for node in definition.nodes):
-        raise ValueError("Workflow needs an input node.")
+    if not any(node.type in {"input", "timer"} for node in definition.nodes):
+        raise ValueError("Workflow needs an input or timer node.")
     if not any(node.type == "output" for node in definition.nodes):
         raise ValueError("Workflow needs an output node.")
 
@@ -100,6 +138,43 @@ def workflow_requires_connection(definition: StoredWorkflowDefinition) -> bool:
     return any(node.type == "agent" for node in definition.nodes)
 
 
+def timer_run_node_ids(
+    definition: StoredWorkflowDefinition, timer_node_id: str
+) -> set[str]:
+    nodes = {node.id: node for node in definition.nodes}
+    timer_node = nodes.get(timer_node_id)
+    if timer_node is None or timer_node.type != "timer":
+        raise ValueError("Timer node not found.")
+
+    outgoing: dict[str, list[str]] = defaultdict(list)
+    incoming: dict[str, list[str]] = defaultdict(list)
+    for edge in definition.edges:
+        outgoing[edge.source].append(edge.target)
+        incoming[edge.target].append(edge.source)
+
+    active = {timer_node_id}
+    queue = deque([timer_node_id])
+    while queue:
+        node_id = queue.popleft()
+        for target in outgoing[node_id]:
+            if target not in active:
+                active.add(target)
+                queue.append(target)
+
+    queue = deque(active)
+    while queue:
+        node_id = queue.popleft()
+        for source in incoming[node_id]:
+            source_node = nodes[source]
+            if source_node.type == "timer" and source != timer_node_id:
+                continue
+            if source not in active:
+                active.add(source)
+                queue.append(source)
+
+    return active
+
+
 def topological_node_ids(definition: StoredWorkflowDefinition) -> list[str]:
     node_ids = [node.id for node in definition.nodes]
     outgoing: dict[str, list[str]] = defaultdict(list)
@@ -133,35 +208,76 @@ def topological_node_ids(definition: StoredWorkflowDefinition) -> list[str]:
 
 async def run_workflow_definition(
     *,
-    completion: CompletionCallable | None,
     connection: ProviderConnection | None,
     definition: StoredWorkflowDefinition,
+    default_input: str = "",
+    input_values: Mapping[str, str] | None = None,
+    runtime: FlowentAgentRuntime | None = None,
+    timer_node_id: str = "",
+    workflow_depth: int = 0,
     workflow_id: str,
 ) -> WorkflowRunResponse:
     ordered_ids = validate_workflow_definition(definition)
     if workflow_requires_connection(definition) and connection is None:
         raise ValueError("Choose a provider and model before running.")
 
+    return await run_workflow_once(
+        connection=connection,
+        definition=definition,
+        input_values=WorkflowRunRequestValues(
+            default_input=default_input,
+            input_values=dict(input_values or {}),
+        ),
+        ordered_ids=ordered_ids,
+        runtime=runtime,
+        timer_node_id=timer_node_id,
+        workflow_depth=workflow_depth,
+        workflow_id=workflow_id,
+    )
+
+
+async def run_workflow_once(
+    *,
+    connection: ProviderConnection | None,
+    definition: StoredWorkflowDefinition,
+    input_values: WorkflowRunRequestValues,
+    ordered_ids: list[str],
+    runtime: FlowentAgentRuntime | None = None,
+    timer_node_id: str = "",
+    workflow_depth: int = 0,
+    workflow_id: str,
+) -> WorkflowRunResponse:
     nodes = {node.id: node for node in definition.nodes}
     incoming_edges = edges_by_target(definition.edges)
+    active_node_ids = (
+        timer_run_node_ids(definition, timer_node_id) if timer_node_id else None
+    )
     results: dict[str, WorkflowNodeRunResult] = {
         node.id: WorkflowNodeRunResult(id=node.id, status="pending")
         for node in definition.nodes
     }
     outputs: dict[str, str] = {}
     named_outputs: dict[str, str] = {}
+    remaining_default_input = input_values.default_input
 
     for node_id in ordered_ids:
         node = nodes[node_id]
+        if active_node_ids is not None and node.id not in active_node_ids:
+            continue
         results[node.id] = WorkflowNodeRunResult(id=node.id, status="running")
         try:
             output = await run_node(
-                completion=completion,
                 connection=connection,
+                default_input=remaining_default_input,
+                input_values=input_values.input_values,
                 incoming_edges=incoming_edges[node.id],
                 node=node,
                 outputs=outputs,
+                runtime=runtime,
+                workflow_depth=workflow_depth,
             )
+            if node.type == "input" and remaining_default_input:
+                remaining_default_input = ""
         except Exception as error:
             results[node.id] = WorkflowNodeRunResult(
                 error=str(error) or "Node could not be completed.",
@@ -193,38 +309,79 @@ async def run_workflow_definition(
 
 async def run_node(
     *,
-    completion: CompletionCallable | None,
     connection: ProviderConnection | None,
+    default_input: str,
+    input_values: Mapping[str, str],
     incoming_edges: list[StoredWorkflowEdge],
     node: StoredWorkflowNode,
     outputs: Mapping[str, str],
+    runtime: FlowentAgentRuntime | None = None,
+    workflow_depth: int = 0,
 ) -> str:
     if node.type == "input":
+        if node.id in input_values:
+            return input_values[node.id]
+        if default_input:
+            return default_input
         return node_data_text(node, "default_value")
     if node.type == "agent":
         if connection is None:
             raise ValueError("Choose a provider and model before running.")
+        if runtime is None:
+            raise ValueError("Agent runtime is not available.")
         prompt = render_template(
             node_data_text(node, "prompt")
             or joined_upstream_outputs(incoming_edges, outputs),
             outputs,
         )
-        response = await complete_chat(
-            connection,
-            [ChatMessage(role="user", content=prompt)],
-            completion=completion,
+        result = await runtime.complete(
+            connection=connection,
+            messages=[
+                *runtime_context_messages(
+                    runtime.cwd, runtime.store.read_state().settings.agent_prompt
+                ),
+                {"role": "user", "content": prompt},
+            ],
+            user_request=prompt,
+            workflow_depth=workflow_depth,
         )
-        return response.content
+        return result.content
     if node.type == "merge":
         upstream = upstream_outputs(incoming_edges, outputs)
         if node_data_text(node, "merge_strategy") == "json":
             return merge_json_outputs(upstream)
         return "\n".join(output for output in upstream if output)
+    if node.type == "code":
+        return await run_code_node(node, upstream_outputs(incoming_edges, outputs))
+    if node.type == "timer":
+        return timer_payload(node)
     if node.type == "output":
         return joined_upstream_outputs(incoming_edges, outputs)
     raise ValueError("Node type is not supported.")
 
 
+async def run_code_node(node: StoredWorkflowNode, upstream: list[str]) -> str:
+    code = node_data_text(node, "code")
+    if not code.strip():
+        return joined_text(upstream)
+    with tempfile.TemporaryDirectory(prefix="flowent-workflow-code-") as code_dir:
+        result = await SandboxRunner(timeout_seconds=10, cwd=Path(code_dir)).run_async(
+            [sys.executable, "-I", "-c", PYTHON_CODE_RUNNER],
+            input_text=json.dumps(
+                {
+                    "code": code,
+                    "input": joined_text(upstream),
+                    "inputs": upstream,
+                },
+                ensure_ascii=False,
+            ),
+            timeout_seconds=10,
+        )
+    if result.exit_code != 0:
+        raise ValueError((result.stderr or result.stdout).strip() or "Code failed.")
+    return result.stdout
+
+
 def edges_by_target(
     edges: list[StoredWorkflowEdge],
 ) -> dict[str, list[StoredWorkflowEdge]]:
@@ -247,6 +404,10 @@ def node_output_key(node: StoredWorkflowNode) -> str:
     return node_data_text(node, "output_key") or node.id
 
 
+def timer_payload(node: StoredWorkflowNode) -> str:
+    return node_data_text(node, "payload") or "Timer fired."
+
+
 def upstream_outputs(
     incoming_edges: list[StoredWorkflowEdge],
     outputs: Mapping[str, str],
@@ -258,9 +419,11 @@ def joined_upstream_outputs(
     incoming_edges: list[StoredWorkflowEdge],
     outputs: Mapping[str, str],
 ) -> str:
-    return "\n".join(
-        output for output in upstream_outputs(incoming_edges, outputs) if output
-    )
+    return joined_text(upstream_outputs(incoming_edges, outputs))
+
+
+def joined_text(values: list[str]) -> str:
+    return "\n".join(value for value in values if value)
 
 
 def render_template(template: str, outputs: Mapping[str, str]) -> str:

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

@@ -10,14 +10,13 @@ from uuid import uuid4
 
 from fastapi import HTTPException
 
-from flowent.agent import AgentContextUpdate, run_agent_stream
-from flowent.approval import ApprovalReviewRequest, review_approval_request
+from flowent.agent import AgentContextUpdate
+from flowent.agent_runtime import FlowentAgentRuntime
 from flowent.compact import CompactInput, CompactProvider
 from flowent.context import runtime_context_messages
 from flowent.llm import ChatMessage, CompletionCallable, ProviderConnection
 from flowent.logging import TRACE_LEVEL
 from flowent.mcp import McpManager
-from flowent.permissions import run_tool_with_path_permissions
 from flowent.provider_connections import selected_connection
 from flowent.skills import explicit_skill_messages
 from flowent.storage import (
@@ -27,7 +26,7 @@ from flowent.storage import (
     StoredState,
     StoredToolItem,
 )
-from flowent.tools import ToolContext, text_tool_result, tool_specs
+from flowent.tools import text_tool_result
 from flowent.usage import (
     TokenUsage,
     TokenUsageInfo,
@@ -36,6 +35,7 @@ from flowent.usage import (
     is_context_window_error,
     recompute_context_usage,
 )
+from flowent.workflow_service import WorkflowService
 from flowent.workspace.context import (
     COMPACTED_CONTEXT_MARKER,
     OPTIMIZED_CONTEXT_MARKER,
@@ -86,16 +86,33 @@ class WorkspaceRuntime:
         cwd: Path,
         mcp_manager: McpManager,
         store: StateStore,
+        workflow_service: WorkflowService,
     ) -> None:
         self.chat_completion = chat_completion
         self.compact_provider = compact_provider
         self.cwd = cwd
-        self.mcp_manager = mcp_manager
         self.store = store
+        self.workflow_service = workflow_service
+        self.agent_runtime = FlowentAgentRuntime(
+            chat_completion=chat_completion,
+            cwd=cwd,
+            mcp_manager=mcp_manager,
+            store=store,
+            workflow_service=workflow_service,
+        )
         self.active_response: WorkspaceResponse | None = None
         self.generation = 0
         self.active_compact_task: WorkspaceCompactTask | None = None
 
+    def extra_tool_specs(self) -> list[Mapping[str, object]]:
+        return self.agent_runtime.extra_tool_specs()
+
+    def model_tool_specs(self) -> list[Mapping[str, object]]:
+        return self.agent_runtime.model_tool_specs()
+
+    def extra_tool_title(self, name: str) -> str | None:
+        return self.agent_runtime.extra_tool_title(name)
+
     def request_messages_for_content(
         self,
         state: StoredState,
@@ -229,10 +246,7 @@ class WorkspaceRuntime:
         )
         next_messages = [*state.messages, user_message]
         self.store.save_messages(next_messages)
-        model_tool_specs = [
-            *tool_specs(),
-            *list(self.mcp_manager.tool_specs()),
-        ]
+        model_tool_specs = self.model_tool_specs()
         model_history: list[ChatMessage | Mapping[str, object]] = [
             *runtime_context_messages(self.cwd, state.settings.agent_prompt),
             *workspace_chat_messages(
@@ -265,42 +279,11 @@ class WorkspaceRuntime:
         current_output_index = 0
         latest_usage_output_index: int | None = None
 
-        async def review_tool_approval(request: ApprovalReviewRequest):
-            return await review_approval_request(
-                connection,
-                request.model_copy(
-                    update={
-                        "transcript": approval_transcript(next_messages),
-                        "user_request": content,
-                    }
-                ),
-                completion=self.chat_completion,
-            )
-
-        async def tool_runner(
-            name: str,
-            arguments: dict[str, object],
-            context: ToolContext,
-        ):
-            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 for event in run_agent_stream(
-            completion=self.chat_completion,
+        async for event in self.agent_runtime.stream(
+            approval_transcript=approval_transcript(next_messages),
             connection=connection,
-            cwd=self.cwd,
-            extra_tool_runner=self.mcp_manager.run_tool,
-            extra_tool_specs=self.mcp_manager.tool_specs(),
-            extra_tool_title=self.mcp_manager.tool_title,
             messages=request_messages,
-            tool_runner=tool_runner,
+            user_request=content,
         ):
             if event.event == "start":
                 event_id = event.data.get("id")
@@ -617,16 +600,37 @@ class WorkspaceRuntime:
             *base_request_messages,
             *model_visible_assistant_output_messages(trimmed_message),
         ]
-        response = self._start_response_from_messages(
-            content=previous_user_message.content,
-            initial_assistant_message=trimmed_message,
-            next_messages=next_messages,
-            output_start_index=assistant_retry_output_start_index(trimmed_message),
-            request_messages=request_messages,
-            state=state_before_assistant,
-            usage_request_messages=base_request_messages,
-            user_message=previous_user_message,
-        )
+        try:
+            response = self._start_response_from_messages(
+                content=previous_user_message.content,
+                initial_assistant_message=trimmed_message,
+                next_messages=next_messages,
+                output_start_index=assistant_retry_output_start_index(trimmed_message),
+                request_messages=request_messages,
+                state=state_before_assistant,
+                usage_request_messages=base_request_messages,
+                user_message=previous_user_message,
+            )
+        except HTTPException as error:
+            error_detail = str(error.detail or "")
+            assistant_output = AssistantOutputBuilder.from_message(trimmed_message)
+            assistant_output.append_error(
+                run_error_output_item(trimmed_message.id, error_detail).model_copy(
+                    update={"id": error_id}
+                )
+            )
+            failed_message = StoredMessage(
+                author="assistant",
+                content=assistant_output.content,
+                groups=assistant_output.groups,
+                id=trimmed_message.id,
+                status="failed",
+                thinking=assistant_output.thinking,
+                tools=list(assistant_output.tools.values()),
+                usage_info=self.store.read_usage_info(),
+            )
+            self.store.save_messages([*previous_messages, failed_message])
+            raise
         return next_messages, response
 
     def _start_response_from_messages(
@@ -706,11 +710,14 @@ class WorkspaceRuntime:
             def refresh_assistant(status: str = "running") -> StoredMessage | None:
                 return update_assistant_message(status, persist=False)
 
-            def persist_assistant_progress() -> StoredMessage | None:
+            def persist_assistant_progress(
+                *, force: bool = False
+            ) -> StoredMessage | None:
                 nonlocal last_progress_flush_at
                 now = time.monotonic()
                 if (
-                    last_progress_flush_at > 0
+                    not force
+                    and last_progress_flush_at > 0
                     and now - last_progress_flush_at
                     < WORKSPACE_PROGRESS_FLUSH_INTERVAL_SECONDS
                 ):
@@ -719,15 +726,16 @@ class WorkspaceRuntime:
                 last_progress_flush_at = now
                 return update_assistant_message("running", persist=True)
 
+            def has_tool_result(tool_id: str) -> bool:
+                tool = assistant_output.tools.get(tool_id)
+                return tool is not None and bool(tool.result)
+
             try:
                 current_tool_id: str | None = None
                 turn_usage_info: TokenUsageInfo | None = None
                 current_output_index = 0
                 latest_usage_output_index: int | None = None
-                model_tool_specs = [
-                    *tool_specs(),
-                    *list(self.mcp_manager.tool_specs()),
-                ]
+                model_tool_specs = self.model_tool_specs()
                 if request_messages is None:
                     current_request_messages = self.request_messages_for_content(
                         state,
@@ -809,33 +817,6 @@ class WorkspaceRuntime:
                     else current_request_messages
                 )
 
-                async def review_tool_approval(request: ApprovalReviewRequest):
-                    return await review_approval_request(
-                        connection,
-                        request.model_copy(
-                            update={
-                                "transcript": approval_transcript(next_messages),
-                                "user_request": content,
-                            }
-                        ),
-                        completion=self.chat_completion,
-                    )
-
-                async def tool_runner(
-                    name: str,
-                    arguments: dict[str, object],
-                    context: ToolContext,
-                ):
-                    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 context_compactor(
                     conversation: Sequence[Mapping[str, object]],
                 ) -> AgentContextUpdate | None:
@@ -882,16 +863,12 @@ class WorkspaceRuntime:
                         },
                     )
 
-                async for event in run_agent_stream(
-                    completion=self.chat_completion,
+                async for event in self.agent_runtime.stream(
+                    approval_transcript=approval_transcript(next_messages),
                     connection=connection,
                     context_compactor=context_compactor,
-                    cwd=self.cwd,
-                    extra_tool_runner=self.mcp_manager.run_tool,
-                    extra_tool_specs=self.mcp_manager.tool_specs(),
-                    extra_tool_title=self.mcp_manager.tool_title,
                     messages=current_request_messages,
-                    tool_runner=tool_runner,
+                    user_request=content,
                 ):
                     if not is_current_generation() or response.discard_on_cancel:
                         raise asyncio.CancelledError
@@ -936,6 +913,17 @@ class WorkspaceRuntime:
                                 StoredToolItem.model_validate(tool)
                             )
                             snapshot_after_event = persist_assistant()
+                    if event.event == "tool_update":
+                        tool_id = event.data.get("id")
+                        if (
+                            isinstance(tool_id, str)
+                            and tool_id in assistant_output.tools
+                        ):
+                            had_result = has_tool_result(tool_id)
+                            assistant_output.update_tool(tool_id, event.data)
+                            snapshot_after_event = persist_assistant_progress(
+                                force=not had_result
+                            )
                     if event.event in {"tool_done", "tool_error"}:
                         tool_id = event.data.get("id")
                         if (

package/backend/uv.lock

@@ -701,7 +701,7 @@ wheels = [
 
 [[package]]
 name = "flowent"
-version = "0.3.2"
+version = "0.3.4"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi", extra = ["standard"] },