npm - flowent - Versions diffs - 0.3.2 → 0.3.3 - Mend

flowent 0.3.2 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/backend/pyproject.toml +1 -1
package/backend/src/flowent/agent.py +61 -2
package/backend/src/flowent/app.py +7 -2
package/backend/src/flowent/permissions.py +12 -3
package/backend/src/flowent/routes/workflow_routes.py +9 -41
package/backend/src/flowent/sandbox.py +63 -19
package/backend/src/flowent/state/models.py +1 -1
package/backend/src/flowent/static/assets/index-CCf0mo80.css +2 -0
package/backend/src/flowent/static/assets/index-CROofCFl.js +102 -0
package/backend/src/flowent/static/index.html +2 -2
package/backend/src/flowent/tools.py +60 -4
package/backend/src/flowent/workflow_service.py +93 -0
package/backend/src/flowent/workflow_tools.py +271 -0
package/backend/src/flowent/workflows.py +71 -3
package/backend/src/flowent/workspace/runtime.py +79 -17
package/backend/uv.lock +1 -1
package/dist/frontend/assets/index-CCf0mo80.css +2 -0
package/dist/frontend/assets/index-CROofCFl.js +102 -0
package/dist/frontend/index.html +2 -2
package/package.json +1 -1
package/backend/src/flowent/static/assets/index-BX18a4Jz.js +0 -100
package/backend/src/flowent/static/assets/index-EC37agAH.css +0 -2
package/dist/frontend/assets/index-BX18a4Jz.js +0 -100
package/dist/frontend/assets/index-EC37agAH.css +0 -2

package/backend/src/flowent/static/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Flowent</title>
     <meta name="description" content="Flowent application" />
-    <script type="module" crossorigin src="/assets/index-BX18a4Jz.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-EC37agAH.css">
+    <script type="module" crossorigin src="/assets/index-CROofCFl.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CCf0mo80.css">
   </head>
   <body>
     <div id="root"></div>

package/backend/src/flowent/tools.py CHANGED Viewed

@@ -6,7 +6,7 @@ import subprocess
 import sys
 import urllib.parse
 import urllib.request
-from collections.abc import Callable, Sequence
+from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 from uuid import uuid4
@@ -28,9 +28,57 @@ class ToolResult(BaseModel):
     title: str
+ToolEventEmitter = Callable[[dict[str, object]], Awaitable[None]]
+class CommandOutputCollector:
+    def __init__(
+        self, command: str, emit_event: ToolEventEmitter | None = None
+    ) -> None:
+        self.command = command
+        self.emit_event = emit_event
+        self.output_chunks: list[dict[str, str]] = []
+    @property
+    def stdout(self) -> str:
+        return "".join(
+            item["content"] for item in self.output_chunks if item["stream"] == "stdout"
+        )
+    @property
+    def stderr(self) -> str:
+        return "".join(
+            item["content"] for item in self.output_chunks if item["stream"] == "stderr"
+        )
+    def result(self) -> dict[str, object]:
+        return {
+            "type": "command",
+            "command": self.command,
+            "output_chunks": [dict(item) for item in self.output_chunks],
+            "stderr": self.stderr,
+            "stdout": self.stdout,
+            "output": self.stdout or self.stderr,
+        }
+    async def append(self, stream: str, content: str) -> None:
+        if not content:
+            return
+        self.output_chunks.append({"stream": stream, "content": content})
+        if self.emit_event is not None:
+            await self.emit_event({"result": self.result(), "status": "running"})
+    async def append_stderr(self, content: str) -> None:
+        await self.append("stderr", content)
+    async def append_stdout(self, content: str) -> None:
+        await self.append("stdout", content)
 @dataclass(frozen=True)
 class ToolContext:
     cwd: Path
+    emit_event: ToolEventEmitter | None = None
     web_searcher: Callable[[str], Sequence[dict[str, str]]] | None = None
@@ -42,6 +90,7 @@ def command_tool_result(
     *,
     command: str,
     exit_code: int,
+    output_chunks: list[dict[str, str]] | None = None,
     stderr: str,
     stdout: str,
 ) -> dict[str, object]:
@@ -49,6 +98,7 @@ def command_tool_result(
         "type": "command",
         "command": command,
         "exit_code": exit_code,
+        "output_chunks": [dict(item) for item in output_chunks or []],
         "stderr": stderr,
         "stdout": stdout,
         "output": stdout or stderr,
@@ -454,16 +504,22 @@ async def shell_command_async(
     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).run_async(
-        invocation.args, env=invocation.env, timeout_seconds=timeout_seconds
+        invocation.args,
+        env=invocation.env,
+        on_stderr=collector.append_stderr,
+        on_stdout=collector.append_stdout,
+        timeout_seconds=timeout_seconds,
     )
     ok = result.exit_code == 0
     return ToolResult(
         result=command_tool_result(
             command=command,
             exit_code=result.exit_code,
-            stderr=result.stderr,
-            stdout=result.stdout,
+            output_chunks=collector.output_chunks,
+            stderr=result.stderr or collector.stderr,
+            stdout=result.stdout or collector.stdout,
         ),
         ok=ok,
         title=f"Ran {command}",

package/backend/src/flowent/workflow_service.py ADDED Viewed

@@ -0,0 +1,93 @@
+from __future__ import annotations
+from collections.abc import Mapping
+from flowent.llm import CompletionCallable
+from flowent.provider_connections import selected_connection
+from flowent.storage import StateStore, StoredWorkflow, StoredWorkflowDefinition
+from flowent.workflows import (
+    WorkflowRunResponse,
+    run_workflow_definition,
+    validate_workflow_draft,
+    workflow_requires_connection,
+)
+class WorkflowService:
+    def __init__(
+        self,
+        *,
+        chat_completion: CompletionCallable | None,
+        store: StateStore,
+    ) -> None:
+        self.chat_completion = chat_completion
+        self.store = store
+    def list_workflows(self) -> list[StoredWorkflow]:
+        return self.store.read_workflows()
+    def get_workflow(self, workflow_id: str) -> StoredWorkflow:
+        workflow = next(
+            (
+                current_workflow
+                for current_workflow in self.store.read_workflows()
+                if current_workflow.id == workflow_id
+            ),
+            None,
+        )
+        if workflow is None:
+            raise ValueError("Workflow not found.")
+        return workflow
+    def save_workflow(self, workflow: StoredWorkflow) -> StoredWorkflow:
+        return self.store.save_workflow(
+            validate_workflow_draft(
+                workflow.model_copy(
+                    update={"name": workflow.name.strip() or "Untitled Workflow"}
+                )
+            )
+        )
+    async def run_workflow(
+        self,
+        workflow_id: str,
+        *,
+        default_input: str = "",
+        input_values: Mapping[str, str] | None = None,
+    ) -> WorkflowRunResponse:
+        workflow = self.get_workflow(workflow_id)
+        connection = (
+            selected_connection(self.store.read_state())
+            if workflow_requires_connection(workflow.definition)
+            else None
+        )
+        return await run_workflow_definition(
+            completion=self.chat_completion,
+            connection=connection,
+            default_input=default_input,
+            definition=workflow.definition,
+            input_values=input_values,
+            workflow_id=workflow.id,
+        )
+    async def run_workflow_definition(
+        self,
+        *,
+        default_input: str = "",
+        definition: StoredWorkflowDefinition,
+        input_values: Mapping[str, str] | None = None,
+        workflow_id: str,
+    ) -> WorkflowRunResponse:
+        connection = (
+            selected_connection(self.store.read_state())
+            if workflow_requires_connection(definition)
+            else None
+        )
+        return await run_workflow_definition(
+            completion=self.chat_completion,
+            connection=connection,
+            default_input=default_input,
+            definition=definition,
+            input_values=input_values,
+            workflow_id=workflow_id,
+        )

package/backend/src/flowent/workflow_tools.py ADDED Viewed

@@ -0,0 +1,271 @@
+from __future__ import annotations
+from pydantic import ValidationError
+from flowent.storage import StoredWorkflow
+from flowent.tools import ToolResult, text_tool_result
+from flowent.workflow_service import WorkflowService
+from flowent.workflows import WorkflowRunResponse
+def workflow_tool_specs() -> list[dict[str, object]]:
+    workflow_schema: dict[str, object] = {"type": "object"}
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "list_workflows",
+                "description": "List saved workflows with their ids, names, node counts, and edge counts.",
+                "parameters": {"type": "object", "properties": {}},
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "get_workflow",
+                "description": "Read a saved workflow definition by id before answering questions or editing it.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"workflow_id": {"type": "string"}},
+                    "required": ["workflow_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "run_workflow",
+                "description": "Run a saved workflow. Pass input when the user's current message contains the content the workflow should process.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "workflow_id": {"type": "string"},
+                        "input": {"type": "string"},
+                        "inputs": {
+                            "type": "object",
+                            "additionalProperties": {"type": "string"},
+                        },
+                    },
+                    "required": ["workflow_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "create_workflow",
+                "description": "Create a workflow. workflow must include id, name, and definition with version, nodes, and edges.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"workflow": workflow_schema},
+                    "required": ["workflow"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "update_workflow",
+                "description": "Replace an existing workflow. Read it first and provide the complete updated workflow object.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"workflow": workflow_schema},
+                    "required": ["workflow"],
+                },
+            },
+        },
+    ]
+def workflow_tool_title(name: str) -> str | None:
+    if name == "list_workflows":
+        return "Listing workflows"
+    if name == "get_workflow":
+        return "Reading workflow"
+    if name == "run_workflow":
+        return "Running workflow"
+    if name == "create_workflow":
+        return "Creating workflow"
+    if name == "update_workflow":
+        return "Updating workflow"
+    return None
+class WorkflowAgentTools:
+    def __init__(self, service: WorkflowService) -> None:
+        self.service = service
+    async def run_tool(
+        self, name: str, arguments: dict[str, object]
+    ) -> ToolResult | None:
+        title = workflow_tool_title(name)
+        if title is None:
+            return None
+        try:
+            if name == "list_workflows":
+                return self.list_workflows()
+            if name == "get_workflow":
+                return self.get_workflow(arguments)
+            if name == "run_workflow":
+                return await self.run_workflow(arguments)
+            if name == "create_workflow":
+                return self.create_workflow(arguments)
+            if name == "update_workflow":
+                return self.update_workflow(arguments)
+        except Exception as error:
+            return ToolResult(
+                result=text_tool_result(str(error) or "Workflow tool failed."),
+                ok=False,
+                title=title,
+            )
+        return None
+    def list_workflows(self) -> ToolResult:
+        workflows = self.service.list_workflows()
+        summaries = [workflow_summary(workflow) for workflow in workflows]
+        if summaries:
+            output = "\n".join(
+                f"{summary['id']}: {summary['name']} ({summary['node_count']} nodes, {summary['edge_count']} edges)"
+                for summary in summaries
+            )
+        else:
+            output = "No workflows are saved."
+        return ToolResult(
+            result={
+                "type": "workflow_list",
+                "output": output,
+                "workflows": summaries,
+            },
+            title="Listed workflows",
+        )
+    def get_workflow(self, arguments: dict[str, object]) -> ToolResult:
+        workflow = self.service.get_workflow(str(arguments["workflow_id"]))
+        summary = workflow_summary(workflow)
+        output = (
+            f"{workflow.name} has {summary['node_count']} nodes and "
+            f"{summary['edge_count']} edges."
+        )
+        return ToolResult(
+            result={
+                "type": "workflow",
+                "output": output,
+                "summary": summary,
+                "workflow": workflow.model_dump(mode="json"),
+            },
+            title=f"Read {workflow.name}",
+        )
+    async def run_workflow(self, arguments: dict[str, object]) -> ToolResult:
+        workflow_id = str(arguments["workflow_id"])
+        workflow = self.service.get_workflow(workflow_id)
+        result = await self.service.run_workflow(
+            workflow_id,
+            default_input=string_argument(arguments, "input"),
+            input_values=string_map_argument(arguments, "inputs"),
+        )
+        output = workflow_run_output(workflow.name, result)
+        return ToolResult(
+            result={
+                "type": "workflow_run",
+                "node_results": [
+                    node_result.model_dump(mode="json")
+                    for node_result in result.node_results
+                ],
+                "output": output,
+                "outputs": dict(result.outputs),
+                "status": result.status,
+                "workflow_id": workflow.id,
+                "workflow_name": workflow.name,
+            },
+            ok=result.status == "success",
+            title=f"Ran {workflow.name}",
+        )
+    def create_workflow(self, arguments: dict[str, object]) -> ToolResult:
+        workflow = workflow_argument(arguments)
+        try:
+            self.service.get_workflow(workflow.id)
+        except ValueError:
+            saved = self.service.save_workflow(workflow)
+        else:
+            raise ValueError("Workflow already exists.")
+        return saved_workflow_result(saved, "Created")
+    def update_workflow(self, arguments: dict[str, object]) -> ToolResult:
+        workflow = workflow_argument(arguments)
+        self.service.get_workflow(workflow.id)
+        saved = self.service.save_workflow(workflow)
+        return saved_workflow_result(saved, "Updated")
+def string_argument(arguments: dict[str, object], name: str) -> str:
+    value = arguments.get(name, "")
+    if value is None:
+        return ""
+    return value if isinstance(value, str) else str(value)
+def string_map_argument(
+    arguments: dict[str, object], name: str
+) -> dict[str, str] | None:
+    value = arguments.get(name)
+    if not isinstance(value, dict):
+        return None
+    return {str(key): str(item) for key, item in value.items()}
+def workflow_argument(arguments: dict[str, object]) -> StoredWorkflow:
+    value = arguments.get("workflow")
+    if not isinstance(value, dict):
+        raise ValueError("Workflow must be an object.")
+    try:
+        return StoredWorkflow.model_validate(value)
+    except ValidationError as error:
+        raise ValueError(error.errors()[0]["msg"]) from error
+def workflow_summary(workflow: StoredWorkflow) -> dict[str, object]:
+    return {
+        "edge_count": len(workflow.definition.edges),
+        "id": workflow.id,
+        "name": workflow.name,
+        "node_count": len(workflow.definition.nodes),
+        "nodes": [
+            {"id": node.id, "name": node.name, "type": node.type}
+            for node in workflow.definition.nodes
+        ],
+    }
+def workflow_run_output(name: str, result: WorkflowRunResponse) -> str:
+    if result.status == "success":
+        if result.outputs:
+            rendered_outputs = "\n".join(
+                f"{key}: {value}" for key, value in result.outputs.items()
+            )
+            return f"{name} completed.\n{rendered_outputs}"
+        return f"{name} completed."
+    failures = [
+        f"{node_result.id}: {node_result.error}"
+        for node_result in result.node_results
+        if node_result.status == "failed"
+    ]
+    return f"{name} failed.\n" + ("\n".join(failures) or "No failure details.")
+def saved_workflow_result(workflow: StoredWorkflow, action: str) -> ToolResult:
+    summary = workflow_summary(workflow)
+    output = (
+        f"{action} {workflow.name} with {summary['node_count']} nodes and "
+        f"{summary['edge_count']} edges."
+    )
+    return ToolResult(
+        result={
+            "type": "workflow",
+            "output": output,
+            "summary": summary,
+            "workflow": workflow.model_dump(mode="json"),
+        },
+        title=f"{action} {workflow.name}",
+    )

package/backend/src/flowent/workflows.py CHANGED Viewed

@@ -1,7 +1,10 @@
 import json
 import re
+import sys
+import tempfile
 from collections import defaultdict, deque
 from collections.abc import Mapping
+from pathlib import Path
 from pydantic import BaseModel, ConfigDict, Field
@@ -11,6 +14,7 @@ from flowent.llm import (
     ProviderConnection,
     complete_chat,
 )
+from flowent.sandbox import SandboxRunner
 from flowent.storage import (
     StoredWorkflow,
     StoredWorkflowDefinition,
@@ -38,6 +42,31 @@ class WorkflowRunResponse(BaseModel):
 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:
@@ -136,6 +165,8 @@ async def run_workflow_definition(
     completion: CompletionCallable | None,
     connection: ProviderConnection | None,
     definition: StoredWorkflowDefinition,
+    default_input: str = "",
+    input_values: Mapping[str, str] | None = None,
     workflow_id: str,
 ) -> WorkflowRunResponse:
     ordered_ids = validate_workflow_definition(definition)
@@ -150,6 +181,7 @@ async def run_workflow_definition(
     }
     outputs: dict[str, str] = {}
     named_outputs: dict[str, str] = {}
+    remaining_default_input = default_input
     for node_id in ordered_ids:
         node = nodes[node_id]
@@ -158,10 +190,14 @@ async def run_workflow_definition(
             output = await run_node(
                 completion=completion,
                 connection=connection,
+                default_input=remaining_default_input,
+                input_values=input_values or {},
                 incoming_edges=incoming_edges[node.id],
                 node=node,
                 outputs=outputs,
             )
+            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.",
@@ -195,11 +231,17 @@ 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],
 ) -> 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:
@@ -220,11 +262,35 @@ async def run_node(
         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 == "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]]:
@@ -258,9 +324,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: