flowent 0.0.4 → 0.0.5

package/backend/src/flowent/tools/manage_settings.py

@@ -71,6 +71,10 @@ class ManageSettingsTool(Tool):
                 "type": ["boolean", "null"],
                 "description": "Explicit output_image override for the active system model",
             },
+            "structured_output": {
+                "type": ["boolean", "null"],
+                "description": "Explicit structured_output override for the active system model",
+            },
             "max_retries": {
                 "type": "integer",
                 "description": "Maximum retries for transient LLM call failures when retry_policy is limited",
@@ -139,6 +143,7 @@ class ManageSettingsTool(Tool):
             build_model_retry_initial_delay_seconds,
             build_model_retry_max_delay_seconds,
             build_model_retry_policy,
+            build_model_structured_output,
             build_model_timeout_ms,
             get_settings,
             save_settings,
@@ -161,6 +166,7 @@ class ManageSettingsTool(Tool):
         context_window_tokens = args.get("context_window_tokens")
         input_image = args.get("input_image")
         output_image = args.get("output_image")
+        structured_output = args.get("structured_output")
         auto_compact_token_limit = args.get("auto_compact_token_limit")
         model_params = args.get("model_params")
         timestamp_format = args.get("timestamp_format")
@@ -237,6 +243,14 @@ class ManageSettingsTool(Tool):
                 build_model_output_image(output_image, field_name="output_image")
             except ValueError as exc:
                 return json.dumps({"error": str(exc)})
+        if "structured_output" in args:
+            try:
+                build_model_structured_output(
+                    structured_output,
+                    field_name="structured_output",
+                )
+            except ValueError as exc:
+                return json.dumps({"error": str(exc)})
         if "context_window_tokens" in args:
             try:
                 build_model_context_window_tokens(
@@ -293,6 +307,9 @@ class ManageSettingsTool(Tool):
                 ),
                 input_image=input_image if "input_image" in args else MISSING,
                 output_image=output_image if "output_image" in args else MISSING,
+                structured_output=(
+                    structured_output if "structured_output" in args else MISSING
+                ),
                 max_retries=max_retries if max_retries is not None else MISSING,
                 retry_policy=retry_policy if retry_policy is not None else MISSING,
                 timeout_ms=timeout_ms if timeout_ms is not None else MISSING,
@@ -331,6 +348,7 @@ class ManageSettingsTool(Tool):
                 retry_backoff_cap_retries_field_name="retry_backoff_cap_retries",
                 input_image_field_name="input_image",
                 output_image_field_name="output_image",
+                structured_output_field_name="structured_output",
                 context_window_tokens_field_name="context_window_tokens",
                 auto_compact_token_limit_field_name="auto_compact_token_limit",
             )

package/backend/src/flowent/tools/send.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
 
 class SendTool(Tool):
     name = "send"
-    description = "Send a formal message to one current contact."
+    description = "Send to one current contact or output-port path."
     parameters: ClassVar[dict[str, Any]] = {
         "type": "object",
         "properties": {
@@ -18,9 +18,20 @@ class SendTool(Tool):
                 "type": "string",
                 "description": "One target id, name, or unique short id from contacts.",
             },
+            "from_output_port_key": {
+                "type": "string",
+                "description": "Source output port key for workflow path sends.",
+            },
+            "to_input_port_key": {
+                "type": "string",
+                "description": "Target input port key for workflow path sends.",
+            },
+            "value": {
+                "description": "Typed value for workflow path sends. Use ordered parts for parts ports, a string for string ports, or an object for json ports.",
+            },
             "parts": {
                 "type": "array",
-                "description": "Ordered message parts to send.",
+                "description": "Ordered message parts for Assistant and Leader entry contacts.",
                 "items": {
                     "type": "object",
                     "properties": {
@@ -36,7 +47,7 @@ class SendTool(Tool):
                 },
             },
         },
-        "required": ["target", "parts"],
+        "required": ["target"],
         "additionalProperties": False,
     }
 
@@ -44,6 +55,13 @@ class SendTool(Tool):
         target = args.get("target")
         if not isinstance(target, str) or not target.strip():
             raise ValueError("send.target must be a non-empty string")
+        if not agent._is_entry_level_sender():
+            return agent.send_port_value(
+                target_ref=target.strip(),
+                from_output_port_key=args.get("from_output_port_key"),
+                to_input_port_key=args.get("to_input_port_key"),
+                raw_value=args.get("value", args.get("parts")),
+            )
         return agent.send_message(
             target_ref=target.strip(),
             raw_parts=args.get("parts"),

package/backend/src/flowent/tools/set_permissions.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 from typing import TYPE_CHECKING, Any, ClassVar
 
+from flowent.models import NodeType
 from flowent.tools import Tool
 
 if TYPE_CHECKING:
@@ -12,8 +13,8 @@ if TYPE_CHECKING:
 class SetPermissionsTool(Tool):
     name = "set_permissions"
     description = (
-        "Update a workflow's permission boundary by patching its bound Leader's "
-        "allow_network and write_dirs."
+        "Update a workflow's permission boundary by patching its allow_network "
+        "and write_dirs."
     )
     parameters: ClassVar[dict[str, Any]] = {
         "type": "object",
@@ -36,7 +37,10 @@ class SetPermissionsTool(Tool):
     }
 
     def execute(self, agent: Agent, args: dict[str, Any], **_kwargs: Any) -> str:
-        from flowent.graph_service import set_tab_permissions
+        from flowent.graph_service import (
+            resolve_effective_permissions_for_agent,
+            set_tab_permissions,
+        )
         from flowent.settings import (
             build_assistant_allow_network,
             build_assistant_write_dirs,
@@ -48,6 +52,14 @@ class SetPermissionsTool(Tool):
 
         if not isinstance(workflow_id, str) or not workflow_id.strip():
             return json.dumps({"error": "workflow_id must be a non-empty string"})
+        normalized_workflow_id = workflow_id.strip()
+        if (
+            agent.node_type != NodeType.ASSISTANT
+            and agent.config.tab_id != normalized_workflow_id
+        ):
+            return json.dumps(
+                {"error": "Workflow permissions can only be changed for this workflow"}
+            )
 
         allow_network: bool | None = None
         if "allow_network" in args:
@@ -69,12 +81,15 @@ class SetPermissionsTool(Tool):
             except ValueError as exc:
                 return json.dumps({"error": str(exc)})
 
+        caller_allow_network, caller_write_dirs = (
+            resolve_effective_permissions_for_agent(agent)
+        )
         result, error = set_tab_permissions(
-            tab_id=workflow_id.strip(),
+            tab_id=normalized_workflow_id,
             allow_network=allow_network,
             write_dirs=write_dirs,
-            caller_allow_network=agent.config.allow_network,
-            caller_write_dirs=list(agent.config.write_dirs),
+            caller_allow_network=caller_allow_network,
+            caller_write_dirs=caller_write_dirs,
             actor_id=agent.uuid,
         )
         if error is not None or result is None:

package/backend/tests/integration/api/test_assistant_api.py

@@ -129,7 +129,7 @@ def test_compact_command_replaces_history_with_summary(monkeypatch, client):
         entry["type"] == "CommandResultEntry"
         and entry["command_name"] == "/compact"
         and entry.get("include_in_context") is False
-        and "Compacted the current Assistant execution context." in entry["content"]
+        and "Compacted this chat for future replies." in entry["content"]
         and "Focus: slash command rollout" in entry["content"]
         and "Ship the slash commands." not in entry["content"]
         for entry in detail["history"]

package/backend/tests/integration/api/test_nodes_api.py

@@ -8,6 +8,7 @@ from flowent.models import (
     AgentState,
     AssistantText,
     ImagePart,
+    LLMResponse,
     ReceivedMessage,
     TextPart,
 )
@@ -66,40 +67,72 @@ def test_get_node_detail_includes_runtime_config(client: TestClient):
     assert isinstance(data["tools"], list)
     assert isinstance(data["write_dirs"], list)
     assert isinstance(data["allow_network"], bool)
+    assert data["workflow_permissions"] == {
+        "allow_network": data["allow_network"],
+        "write_dirs": data["write_dirs"],
+    }
 
 
-def test_worker_and_leader_are_stable_contacts_without_explicit_edge(
+def test_worker_contacts_follow_output_paths(
     client: TestClient,
 ):
     tab = client.post(
         "/api/workflows",
-        json={"title": "Execution"},
+        json={"title": "Execution", "allow_network": True, "write_dirs": ["/tmp"]},
     ).json()
     worker = client.post(
         f"/api/workflows/{tab['id']}/nodes",
         json={"role_name": "Worker", "name": "Worker"},
     ).json()
+    reviewer = client.post(
+        f"/api/workflows/{tab['id']}/nodes",
+        json={"role_name": "Worker", "name": "Reviewer"},
+    ).json()
 
     detail_without_edge = client.get(f"/api/nodes/{worker['id']}")
 
     assert detail_without_edge.status_code == 200
-    assert detail_without_edge.json()["contacts"] == [tab["leader_id"]]
+    worker_detail = detail_without_edge.json()
+    assert worker_detail["contacts"] == []
+    assert worker_detail["allow_network"] is True
+    assert worker_detail["write_dirs"] == ["/tmp"]
+    assert worker_detail["workflow_permissions"] == {
+        "allow_network": True,
+        "write_dirs": ["/tmp"],
+    }
     leader_without_edge = client.get(f"/api/nodes/{tab['leader_id']}")
     assert leader_without_edge.status_code == 200
-    assert worker["id"] in leader_without_edge.json()["contacts"]
+    assert any(
+        contact["id"] == worker["id"]
+        for contact in leader_without_edge.json()["contacts"]
+    )
 
     edge_response = client.post(
         f"/api/workflows/{tab['id']}/edges",
         json={
-            "from_node_id": tab["leader_id"],
-            "to_node_id": worker["id"],
+            "from_node_id": worker["id"],
+            "to_node_id": reviewer["id"],
         },
     )
 
-    assert edge_response.status_code == 400
-    assert edge_response.json()["detail"] == (
-        "Workflow Leader does not participate in Workflow Graph edges"
-    )
+    assert edge_response.status_code == 200
+    edge = edge_response.json()
+    worker_with_edge = client.get(f"/api/nodes/{worker['id']}").json()
+    assert worker_with_edge["contacts"] == [
+        {
+            "id": reviewer["id"],
+            "target_id": reviewer["id"],
+            "node_type": "agent",
+            "role_name": "Worker",
+            "name": "Reviewer",
+            "state": "idle",
+            "is_leader": False,
+            "from_output_port_key": "out",
+            "to_input_port_key": "in",
+            "port_type": "parts",
+            "edge_id": edge["id"],
+        }
+    ]
 
 
 def test_direct_node_message_api_is_not_available(client: TestClient):
@@ -131,9 +164,13 @@ def test_get_assistant_detail_includes_tools_and_permissions(client: TestClient)
     assert set(data["tools"]) == set(MINIMUM_TOOLS) | set(STEWARD_ROLE_INCLUDED_TOOLS)
     assert data["write_dirs"] == [os.getcwd()]
     assert data["allow_network"] is True
+    assert data["workflow_permissions"] == {
+        "allow_network": True,
+        "write_dirs": [os.getcwd()],
+    }
 
 
-def test_get_node_detail_includes_state_entries_in_history(client: TestClient):
+def test_get_node_detail_keeps_state_out_of_history(client: TestClient):
     assistant_id = _get_assistant_id(client)
     assistant = registry.get(assistant_id)
     assert assistant is not None
@@ -142,11 +179,9 @@ def test_get_node_detail_includes_state_entries_in_history(client: TestClient):
     response = client.get(f"/api/nodes/{assistant_id}")
 
     assert response.status_code == 200
-    history = response.json()["history"]
-    assert any(
-        entry["type"] == "StateEntry" and entry["state"] == "running"
-        for entry in history
-    )
+    data = response.json()
+    assert data["state"] == "running"
+    assert all(entry["type"] != "StateEntry" for entry in data["history"])
 
 
 def test_assistant_cannot_be_terminated_via_nodes_api(client: TestClient):
@@ -233,15 +268,17 @@ def test_assistant_chat_can_be_cleared_via_nodes_api(client: TestClient):
     )
 
 
-def test_human_input_can_be_sent_directly_to_workflow_leader(client: TestClient):
+def test_unknown_slash_input_can_be_sent_directly_to_workflow_leader(
+    client: TestClient,
+):
     tab = client.post(
         "/api/workflows",
-        json={"title": "Execution"},
+        json={"title": "Execution", "allow_network": True},
     ).json()
 
     response = client.post(
         f"/api/nodes/{tab['leader_id']}/messages",
-        json={"content": "/help investigate the failure"},
+        json={"content": "/unknown investigate the failure"},
     )
 
     assert response.status_code == 200
@@ -256,7 +293,7 @@ def test_human_input_can_be_sent_directly_to_workflow_leader(client: TestClient)
             entry["type"] == "ReceivedMessage"
             and entry["from_id"] == "human"
             and entry["message_id"] == message_id
-            and entry["content"] == "/help investigate the failure"
+            and entry["content"] == "/unknown investigate the failure"
             for entry in history
         ):
             break
@@ -266,11 +303,210 @@ def test_human_input_can_be_sent_directly_to_workflow_leader(client: TestClient)
         entry["type"] == "ReceivedMessage"
         and entry["from_id"] == "human"
         and entry["message_id"] == message_id
-        and entry["content"] == "/help investigate the failure"
+        and entry["content"] == "/unknown investigate the failure"
         for entry in history
     )
 
 
+def test_leader_help_command_returns_visible_command_feedback(client: TestClient):
+    tab = client.post(
+        "/api/workflows",
+        json={"title": "Execution"},
+    ).json()
+
+    response = client.post(
+        f"/api/nodes/{tab['leader_id']}/messages",
+        json={"content": "/help"},
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "status": "command_executed",
+        "command_name": "/help",
+    }
+
+    detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
+
+    assert any(
+        entry["type"] == "CommandResultEntry"
+        and entry["command_name"] == "/help"
+        and "Available commands" in entry["content"]
+        and "/compact" in entry["content"]
+        for entry in detail["history"]
+    )
+    assert not any(
+        entry["type"] == "ReceivedMessage" and entry.get("content") == "/help"
+        for entry in detail["history"]
+    )
+
+
+def test_leader_clear_command_clears_only_workflow_chat(client: TestClient):
+    assistant_id = _get_assistant_id(client)
+    assistant = registry.get(assistant_id)
+    assert assistant is not None
+    assistant.history.append(
+        ReceivedMessage(content="Assistant stays", from_id="human")
+    )
+    tab = client.post(
+        "/api/workflows",
+        json={"title": "Execution"},
+    ).json()
+    worker = client.post(
+        f"/api/workflows/{tab['id']}/nodes",
+        json={"role_name": "Worker", "name": "Worker"},
+    ).json()
+    leader = registry.get(tab["leader_id"])
+    assert leader is not None
+    leader.history.append(ReceivedMessage(content="Old workflow chat", from_id="human"))
+    leader.history.append(AssistantText(content="Old workflow reply"))
+
+    response = client.post(
+        f"/api/nodes/{tab['leader_id']}/messages",
+        json={"content": "/clear"},
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "status": "command_executed",
+        "command_name": "/clear",
+    }
+
+    leader_detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
+    assistant_detail = client.get(f"/api/nodes/{assistant_id}").json()
+    workflow = client.get(f"/api/workflows/{tab['id']}").json()
+
+    assert not any(
+        entry["type"] in {"ReceivedMessage", "AssistantText"}
+        and entry.get("content") in {"Old workflow chat", "Old workflow reply"}
+        for entry in leader_detail["history"]
+    )
+    assert not any(
+        entry["type"] == "CommandResultEntry" and entry["command_name"] == "/clear"
+        for entry in leader_detail["history"]
+    )
+    assert any(
+        entry["type"] == "ReceivedMessage" and entry.get("content") == "Assistant stays"
+        for entry in assistant_detail["history"]
+    )
+    assert any(node["id"] == worker["id"] for node in workflow["nodes"])
+
+
+def test_leader_compact_command_keeps_history_and_adds_system_feedback(
+    monkeypatch,
+    client: TestClient,
+):
+    tab = client.post(
+        "/api/workflows",
+        json={"title": "Execution", "allow_network": True},
+    ).json()
+    leader = registry.get(tab["leader_id"])
+    assert leader is not None
+    leader.history.extend(
+        [
+            ReceivedMessage(content="Need a concise recap", from_id="human"),
+            AssistantText(content="I will summarize the workflow."),
+        ]
+    )
+
+    monkeypatch.setattr(
+        "flowent.agent.gateway.chat",
+        lambda *args, **kwargs: LLMResponse(
+            content=(
+                "## Current Goal\nShip the shared commands.\n\n"
+                "## Active Task Boundary\nKeep it in the workflow chat.\n\n"
+                "## Key Constraints\nDo not clear visible history.\n\n"
+                "## Confirmed Decisions\nUse shared commands.\n\n"
+                "## Open Questions\nNone.\n\n"
+                "## Next Actions\nVerify the workflow panel."
+            )
+        ),
+    )
+
+    response = client.post(
+        f"/api/nodes/{tab['leader_id']}/messages",
+        json={"content": "/compact workflow command rollout"},
+    )
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "status": "command_executed",
+        "command_name": "/compact",
+    }
+
+    detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
+
+    assert any(
+        entry["type"] == "ReceivedMessage"
+        and entry.get("content") == "Need a concise recap"
+        for entry in detail["history"]
+    )
+    assert any(
+        entry["type"] == "AssistantText"
+        and entry.get("content") == "I will summarize the workflow."
+        for entry in detail["history"]
+    )
+    assert any(
+        entry["type"] == "CommandResultEntry"
+        and entry["command_name"] == "/compact"
+        and entry.get("include_in_context") is False
+        and "Compacted this chat for future replies." in entry["content"]
+        and "Focus: workflow command rollout" in entry["content"]
+        for entry in detail["history"]
+    )
+
+
+def test_leader_image_message_bypasses_conversation_commands(
+    client: TestClient,
+    monkeypatch,
+):
+    tab = client.post(
+        "/api/workflows",
+        json={"title": "Execution"},
+    ).json()
+    leader = registry.get(tab["leader_id"])
+    assert leader is not None
+    monkeypatch.setattr(leader, "supports_input_image", lambda: True)
+
+    upload_response = client.post(
+        "/api/image-assets",
+        files={"file": ("pixel.png", _ONE_PIXEL_PNG, "image/png")},
+    )
+    assert upload_response.status_code == 200
+    asset_id = upload_response.json()["id"]
+
+    response = client.post(
+        f"/api/nodes/{tab['leader_id']}/messages",
+        json={
+            "parts": [
+                {"type": "text", "text": "/help"},
+                {
+                    "type": "image",
+                    "asset_id": asset_id,
+                    "mime_type": "image/png",
+                    "width": 1,
+                    "height": 1,
+                },
+            ]
+        },
+    )
+
+    assert response.status_code == 200
+    assert response.json()["status"] == "sent"
+
+    detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
+
+    assert any(
+        entry["type"] == "ReceivedMessage"
+        and entry["from_id"] == "human"
+        and entry["content"] == "/help[image]"
+        for entry in detail["history"]
+    )
+    assert not any(
+        entry["type"] == "CommandResultEntry" and entry["command_name"] == "/help"
+        for entry in detail["history"]
+    )
+
+
 def test_leader_retry_rewrites_tail_and_reuses_image_parts(monkeypatch, client):
     assistant_id = _get_assistant_id(client)
     tab = client.post(

package/backend/tests/integration/api/test_roles_api.py

@@ -64,9 +64,10 @@ def test_roles_bootstrap_includes_tools_and_providers(client: TestClient, monkey
     ]
     assert {role["name"] for role in payload["roles"]} == {"Steward", "Reviewer"}
     tool_names = {tool["name"] for tool in payload["tools"]}
-    assert "delete_workflow" in tool_names
+    assert "delete_workflow" not in tool_names
+    assert "list_workflows" not in tool_names
     assert "create_agent" in tool_names
-    assert "manage_roles" in tool_names
+    assert "manage_roles" not in tool_names
 
 
 def test_create_role_rejects_duplicate_name(client: TestClient, monkeypatch):