flowent 0.3.1 → 0.3.3

package/backend/src/flowent/workflow_tools.py

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

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

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

@@ -12,10 +12,11 @@ from flowent.storage import (
     StoredSettings,
     StoredState,
 )
+from flowent.tools import tool_result_model_content
 from flowent.usage import (
     TokenUsageInfo,
     current_model_context_window,
-    estimated_token_usage_for_messages,
+    estimated_token_usage_for_request,
     recompute_context_usage,
 )
 from flowent.workspace.output import error_context_summary, message_error_items
@@ -51,13 +52,15 @@ def should_auto_compact(
     messages: Sequence[ChatMessage | Mapping[str, object]],
     *,
     context_window: int,
+    tools: Sequence[Mapping[str, object]] = (),
 ) -> bool:
     token_limit = auto_compact_token_limit(context_window)
     if token_limit <= 0:
         return False
     return (
-        estimated_token_usage_for_messages(
-            model_request_messages_data(messages)
+        estimated_token_usage_for_request(
+            model_request_messages_data(messages),
+            tools=tools,
         ).total_tokens
         >= token_limit
     )
@@ -83,17 +86,19 @@ def update_context_usage_for_response(
     messages: Sequence[Mapping[str, object]],
     output_content: str,
     output_tools: Sequence[Mapping[str, object]] = (),
+    request_tools: Sequence[Mapping[str, object]] = (),
     model_context_window: int,
 ) -> TokenUsageInfo:
     return recompute_context_usage(
         usage_info,
-        estimated_token_usage_for_messages(
+        estimated_token_usage_for_request(
             [
                 *model_visible_messages_for_usage(messages),
                 *model_visible_response_messages_for_usage(
                     output_content, output_tools
                 ),
             ],
+            tools=request_tools,
         ).total_tokens,
         model_context_window=model_context_window,
     )
@@ -107,6 +112,8 @@ def model_visible_response_messages_for_usage(
     for index, tool in enumerate(output_tools):
         tool_id = str(tool.get("id") or f"call_{index}")
         arguments = tool.get("arguments")
+        result_payload = tool.get("result")
+        tool_result = result_payload if isinstance(result_payload, dict) else {}
         visible_messages.append(
             {
                 "role": "assistant",
@@ -130,7 +137,7 @@ def model_visible_response_messages_for_usage(
             {
                 "role": "tool",
                 "tool_call_id": tool_id,
-                "content": str(tool.get("content") or ""),
+                "content": tool_result_model_content(tool_result),
             }
         )
     if output_content:
@@ -175,7 +182,7 @@ def model_visible_assistant_output_messages(
             {
                 "role": "tool",
                 "tool_call_id": tool.id,
-                "content": tool.content or "",
+                "content": tool_result_model_content(tool.result or {}),
             }
             for tool in group_tools
             if tool.status != "running"
@@ -260,7 +267,7 @@ def usage_info_for_model(
     model_context_window: int,
 ) -> TokenUsageInfo | None:
     if usage_info is None:
-        return None
+        return TokenUsageInfo(model_context_window=model_context_window)
     return usage_info.model_copy(update={"model_context_window": model_context_window})
 
 

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

@@ -13,6 +13,7 @@ from flowent.storage import (
     StoredToolItem,
     StoredToolOutputItem,
 )
+from flowent.tools import tool_result_model_content
 
 APPROVAL_TRANSCRIPT_MESSAGE_LIMIT = 12
 APPROVAL_TRANSCRIPT_TEXT_LIMIT = 2_000
@@ -84,7 +85,9 @@ def approval_transcript(
             if content:
                 entries.append(ApprovalTranscriptEntry(role=role, content=content))
             for tool in message.tools:
-                tool_content = approval_transcript_text(tool.content)
+                tool_content = approval_transcript_text(
+                    tool_result_model_content(tool.result or {})
+                )
                 if tool_content:
                     entries.append(
                         ApprovalTranscriptEntry(