flowent 0.0.5 → 0.0.7

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

@@ -1,13 +1,17 @@
 import base64
+import threading
 from uuid import UUID
 
 from flowent.models import (
+    AgentState,
     AssistantText,
+    ErrorEntry,
     ImagePart,
     LLMResponse,
     ReceivedMessage,
     TextPart,
 )
+from flowent.providers.errors import LLMProviderError
 from flowent.registry import registry
 
 _ONE_PIXEL_PNG = base64.b64decode(
@@ -77,6 +81,70 @@ def test_clear_command_clears_history_back_to_empty_state(client):
     )
 
 
+def test_assistant_accepts_new_message_after_error(monkeypatch, client):
+    assistant_id = _get_assistant_id(client)
+    assistant = registry.get(assistant_id)
+    assert assistant is not None
+    chat_started = threading.Event()
+    release_chat = threading.Event()
+
+    def fake_chat(**kwargs):
+        chat_started.set()
+        release_chat.wait(timeout=2)
+        raise LLMProviderError(
+            "LLM API error\nDetail: still invalid",
+            transient=False,
+        )
+
+    monkeypatch.setattr("flowent.agent.gateway.chat", fake_chat)
+    assistant.history.append(ErrorEntry(content="LLM API error\nDetail: Invalid key"))
+    assistant.set_state(AgentState.ERROR, "LLM API error")
+
+    try:
+        response = client.post(
+            "/api/assistant/message",
+            json={"content": "Continue with a safer plan"},
+        )
+
+        assert response.status_code == 200
+        message_id = response.json()["message_id"]
+        assert isinstance(message_id, str)
+        assert chat_started.wait(timeout=1)
+
+        detail = client.get(f"/api/nodes/{assistant_id}").json()
+        history = detail["history"]
+        assert any(
+            entry["type"] == "ErrorEntry"
+            and entry["content"] == "LLM API error\nDetail: Invalid key"
+            for entry in history
+        )
+        assert any(
+            entry["type"] == "ReceivedMessage"
+            and entry["from_id"] == "human"
+            and entry["message_id"] == message_id
+            and entry["content"] == "Continue with a safer plan"
+            for entry in history
+        )
+        assert registry.get(assistant_id).state == AgentState.RUNNING
+    finally:
+        release_chat.set()
+
+
+def test_assistant_rejects_message_when_terminated(client):
+    assistant_id = _get_assistant_id(client)
+    assistant = registry.get(assistant_id)
+    assert assistant is not None
+    assistant.set_state(AgentState.TERMINATED, "done")
+
+    response = client.post(
+        "/api/assistant/message",
+        json={"content": "Continue"},
+    )
+
+    assert response.status_code == 409
+    assert response.json()["detail"] == "Assistant is no longer available"
+
+
 def test_compact_command_replaces_history_with_summary(monkeypatch, client):
     assistant_id = _get_assistant_id(client)
     assistant = registry.get(assistant_id)

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

@@ -6,7 +6,6 @@ def test_tools_api_shows_agent_visible_management_tools(client: TestClient):
 
     assert response.status_code == 200
     tool_names = {tool["name"] for tool in response.json()["tools"]}
-    assert "create_root" not in tool_names
     assert "manage_providers" in tool_names
     assert "manage_roles" in tool_names
     assert "manage_settings" in tool_names

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

@@ -1,4 +1,5 @@
 import os
+import threading
 import time
 from uuid import UUID
 
@@ -7,13 +8,14 @@ from fastapi.testclient import TestClient
 from flowent.models import (
     AgentState,
     AssistantText,
+    ErrorEntry,
     ImagePart,
     LLMResponse,
     ReceivedMessage,
     TextPart,
 )
+from flowent.providers.errors import LLMProviderError
 from flowent.registry import registry
-from flowent.routes.nodes import router as nodes_router
 from flowent.settings import STEWARD_ROLE_INCLUDED_TOOLS
 from flowent.tools import MINIMUM_TOOLS
 
@@ -135,13 +137,6 @@ def test_worker_contacts_follow_output_paths(
     ]
 
 
-def test_direct_node_message_api_is_not_available(client: TestClient):
-    assert not any(
-        getattr(route, "path", None) == "/api/nodes/{node_id}/message"
-        for route in nodes_router.routes
-    )
-
-
 def test_only_assistant_node_exists_at_startup(client: TestClient):
     list_response = client.get("/api/nodes")
 
@@ -308,6 +303,76 @@ def test_unknown_slash_input_can_be_sent_directly_to_workflow_leader(
     )
 
 
+def test_leader_accepts_new_message_after_error(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
+    chat_started = threading.Event()
+    release_chat = threading.Event()
+
+    def fake_chat(**kwargs):
+        chat_started.set()
+        release_chat.wait(timeout=2)
+        raise LLMProviderError(
+            "LLM API error\nDetail: still invalid",
+            transient=False,
+        )
+
+    monkeypatch.setattr("flowent.agent.gateway.chat", fake_chat)
+    leader.history.append(ErrorEntry(content="LLM API error\nDetail: Invalid key"))
+    leader.set_state(AgentState.ERROR, "LLM API error")
+
+    try:
+        response = client.post(
+            f"/api/nodes/{tab['leader_id']}/messages",
+            json={"content": "Continue the workflow chat"},
+        )
+
+        assert response.status_code == 200
+        message_id = response.json()["message_id"]
+        assert isinstance(message_id, str)
+        assert chat_started.wait(timeout=1)
+
+        detail = client.get(f"/api/nodes/{tab['leader_id']}").json()
+        history = detail["history"]
+        assert any(
+            entry["type"] == "ErrorEntry"
+            and entry["content"] == "LLM API error\nDetail: Invalid key"
+            for entry in history
+        )
+        assert any(
+            entry["type"] == "ReceivedMessage"
+            and entry["from_id"] == "human"
+            and entry["message_id"] == message_id
+            and entry["content"] == "Continue the workflow chat"
+            for entry in history
+        )
+        assert registry.get(tab["leader_id"]).state == AgentState.RUNNING
+    finally:
+        release_chat.set()
+
+
+def test_leader_rejects_message_when_terminated(client: TestClient):
+    tab = client.post(
+        "/api/workflows",
+        json={"title": "Execution"},
+    ).json()
+    leader = registry.get(tab["leader_id"])
+    assert leader is not None
+    leader.set_state(AgentState.TERMINATED, "done")
+
+    response = client.post(
+        f"/api/nodes/{tab['leader_id']}/messages",
+        json={"content": "Continue the workflow chat"},
+    )
+
+    assert response.status_code == 409
+    assert response.json()["detail"] == "This workflow chat is no longer available"
+
+
 def test_leader_help_command_returns_visible_command_feedback(client: TestClient):
     tab = client.post(
         "/api/workflows",

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

@@ -46,24 +46,6 @@ def test_list_tabs_is_empty_at_startup(client: TestClient):
     assert response.json() == {"workflows": []}
 
 
-def test_create_tab_rejects_removed_mcp_servers_field(client: TestClient):
-    response = client.post(
-        "/api/workflows",
-        json={"title": "Review Task", "mcp_servers": ["filesystem"]},
-    )
-
-    assert response.status_code == 422
-
-
-def test_create_tab_rejects_removed_goal_field(client: TestClient):
-    response = client.post(
-        "/api/workflows",
-        json={"title": "Review Task", "goal": "Inspect changed files"},
-    )
-
-    assert response.status_code == 422
-
-
 def test_create_tab_node_and_edge_round_trip(client: TestClient):
     create_tab_response = client.post(
         "/api/workflows",
@@ -335,78 +317,6 @@ def test_tab_edge_creation_enforces_directed_ports_and_single_input(
     )
 
 
-def test_duplicate_tab_copies_definition_and_runtime_agents(client: TestClient):
-    source_tab = client.post(
-        "/api/workflows",
-        json={
-            "title": "Original Workflow",
-            "allow_network": True,
-            "write_dirs": ["/tmp"],
-        },
-    ).json()
-    source_tab_id = source_tab["id"]
-
-    reviewer = _create_agent_node(client, tab_id=source_tab_id, name="Reviewer")
-    formatter = _create_graph_node(
-        client,
-        tab_id=source_tab_id,
-        node_type="code",
-        name="Formatter",
-        config={"language": "python"},
-    )
-    source_detail = client.get(f"/api/workflows/{source_tab_id}").json()
-    source_definition = deepcopy(source_detail["workflow"]["definition"])
-    source_definition["view"] = {
-        "positions": {
-            reviewer["id"]: {"x": 20, "y": 40},
-            formatter["id"]: {"x": 180, "y": 40},
-        }
-    }
-    source_definition["edges"] = [
-        {
-            "id": "edge-review",
-            "from_node_id": reviewer["id"],
-            "from_port_key": "out",
-            "to_node_id": formatter["id"],
-            "to_port_key": "in",
-        }
-    ]
-    update_response = client.put(
-        f"/api/workflows/{source_tab_id}/definition",
-        json={"definition": source_definition},
-    )
-    assert update_response.status_code == 200
-
-    duplicate_response = client.post(f"/api/workflows/{source_tab_id}/duplicate")
-
-    assert duplicate_response.status_code == 200
-    duplicated_tab = duplicate_response.json()
-    assert duplicated_tab["title"] == "Original Workflow Copy"
-    assert "goal" not in duplicated_tab
-    assert duplicated_tab["node_count"] == 2
-    assert duplicated_tab["edge_count"] == 1
-    assert duplicated_tab["id"] != source_tab_id
-    assert duplicated_tab["leader_id"] != source_tab["leader_id"]
-    assert duplicated_tab["activation_state"] == "inactive"
-    assert duplicated_tab["allow_network"] is True
-    assert duplicated_tab["write_dirs"] == ["/tmp"]
-
-    duplicated_detail = client.get(f"/api/workflows/{duplicated_tab['id']}").json()
-    assert "goal" not in duplicated_detail["workflow"]
-    assert duplicated_detail["workflow"]["allow_network"] is True
-    assert duplicated_detail["workflow"]["write_dirs"] == ["/tmp"]
-    assert {node["name"] for node in duplicated_detail["nodes"]} == {
-        "Reviewer",
-        "Formatter",
-    }
-    duplicated_node_ids = {node["id"] for node in duplicated_detail["nodes"]}
-    source_node_ids = {node["id"] for node in source_detail["nodes"]}
-    assert duplicated_node_ids.isdisjoint(source_node_ids)
-    assert duplicated_detail["edges"][0]["from_node_id"] in duplicated_node_ids
-    assert duplicated_detail["edges"][0]["to_node_id"] in duplicated_node_ids
-    assert duplicated_detail["workflow"]["definition"]["view"]["positions"]
-
-
 def test_update_tab_definition_updates_metadata_and_positions(client: TestClient):
     tab = client.post(
         "/api/workflows",
@@ -554,30 +464,6 @@ def test_activate_agent_only_workflow_succeeds_without_trigger(client: TestClien
     assert detail["nodes"][0]["id"] == worker["id"]
 
 
-def test_activate_legacy_agent_only_workflow_succeeds_without_trigger(
-    client: TestClient,
-):
-    tab = client.post("/api/workflows", json={"title": "Legacy Collaborative"}).json()
-    worker = _create_agent_node(client, tab_id=tab["id"], name="Worker")
-    definition = deepcopy(
-        client.get(f"/api/workflows/{tab['id']}").json()["workflow"]["definition"]
-    )
-    definition["nodes"][0]["inputs"][0]["required"] = True
-    update_response = client.put(
-        f"/api/workflows/{tab['id']}/definition",
-        json={"definition": definition},
-    )
-    assert update_response.status_code == 200
-
-    response = client.post(f"/api/workflows/{tab['id']}/activate")
-
-    assert response.status_code == 200
-    assert response.json()["activation_state"] == "active"
-    detail = client.get(f"/api/workflows/{tab['id']}").json()
-    assert detail["workflow"]["activation_state"] == "active"
-    assert detail["nodes"][0]["id"] == worker["id"]
-
-
 def test_activate_valid_manual_trigger_graph_succeeds(client: TestClient):
     tab = client.post("/api/workflows", json={"title": "Manual"}).json()
     trigger = _create_graph_node(

package/backend/tests/unit/agent/test_agent_public_api.py

@@ -672,11 +672,6 @@ def test_list_roles_tool_returns_registered_roles(monkeypatch):
                 "fetch",
                 "list_roles",
                 "list_tools",
-                "list_mcp_resources",
-                "list_mcp_resource_templates",
-                "read_mcp_resource",
-                "list_mcp_prompts",
-                "get_mcp_prompt",
             ],
         },
         {
@@ -699,11 +694,6 @@ def test_list_roles_tool_returns_registered_roles(monkeypatch):
                 "exec",
                 "list_roles",
                 "list_tools",
-                "list_mcp_resources",
-                "list_mcp_resource_templates",
-                "read_mcp_resource",
-                "list_mcp_prompts",
-                "get_mcp_prompt",
             ],
         },
     ]
@@ -735,11 +725,6 @@ def test_list_tools_tool_returns_registered_tool_names_and_descriptions():
         "connect",
         "list_roles",
         "list_tools",
-        "list_mcp_resources",
-        "list_mcp_resource_templates",
-        "read_mcp_resource",
-        "list_mcp_prompts",
-        "get_mcp_prompt",
     }
     assert all(
         {"name", "description", "source", "parameters"} <= set(item) for item in result

package/backend/tests/unit/agent/test_agent_runtime.py

@@ -1118,6 +1118,50 @@ def test_execute_compact_command_replaces_history_with_summary(monkeypatch):
     assert "Compacted this chat for future replies." not in serialized
 
 
+def test_compacted_context_normalizes_legacy_traceback_summary(monkeypatch):
+    monkeypatch.setattr("flowent.agent.get_settings", lambda: Settings())
+
+    assistant = Agent(NodeConfig(node_type=NodeType.ASSISTANT), uuid="assistant")
+    assistant._set_execution_context(
+        summary=(
+            "## Current Goal\nRecover the chat.\n\n"
+            "Traceback (most recent call last):\n"
+            '  File "/tmp/example.py", line 1, in <module>\n'
+            "RuntimeError: boom"
+        ),
+        history_cutoff=0,
+    )
+
+    messages = assistant._build_messages()
+    serialized = json.dumps(messages)
+
+    assert "Compacted execution context" in serialized
+    assert "Recover the chat." in serialized
+    assert "Traceback" not in serialized
+    assert "/tmp/example.py" not in serialized
+
+
+def test_compacted_context_normalizes_legacy_html_summary(monkeypatch):
+    monkeypatch.setattr("flowent.agent.get_settings", lambda: Settings())
+
+    assistant = Agent(NodeConfig(node_type=NodeType.ASSISTANT), uuid="assistant")
+    assistant._set_execution_context(
+        summary=(
+            "## Current Goal\nRecover the chat.\n\n"
+            "<!doctype html><html><body>Bad Gateway</body></html>"
+        ),
+        history_cutoff=0,
+    )
+
+    messages = assistant._build_messages()
+    serialized = json.dumps(messages)
+
+    assert "Compacted execution context" in serialized
+    assert "unexpected error response" in serialized
+    assert "<!doctype html" not in serialized
+    assert "<html" not in serialized
+
+
 def test_compact_command_excludes_queued_messages_from_summary(monkeypatch):
     assistant = Agent(NodeConfig(node_type=NodeType.ASSISTANT), uuid="assistant")
     assistant.history.extend(
@@ -2668,18 +2712,120 @@ def test_build_messages_keeps_error_entries_in_context(monkeypatch):
 
     agent = Agent(NodeConfig(node_type=NodeType.AGENT), uuid="agent")
     agent._append_history(ReceivedMessage(content="begin", from_id="human"))
-    agent._append_history(ErrorEntry(content="RuntimeError: boom\n\ntraceback"))
+    agent._append_history(ErrorEntry(content="RuntimeError: boom"))
+
+    messages = agent._build_messages()
+
+    assert any(
+        msg.get("role") == "user"
+        and msg.get("content")
+        == "<system>Previous runtime error:\nRuntimeError: boom</system>"
+        for msg in messages
+    )
+
+
+def test_build_messages_normalizes_legacy_traceback_errors(monkeypatch):
+    monkeypatch.setattr("flowent.agent.get_settings", lambda: Settings())
+
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT), uuid="agent")
+    agent._append_history(
+        ErrorEntry(
+            content=(
+                "RuntimeError: boom\n\n"
+                "Traceback (most recent call last):\n"
+                '  File "/tmp/example.py", line 1, in <module>\n'
+                "RuntimeError: boom"
+            )
+        )
+    )
+
+    messages = agent._build_messages()
+
+    assert any(
+        msg.get("role") == "user"
+        and msg.get("content")
+        == "<system>Previous runtime error:\nRuntimeError: boom</system>"
+        for msg in messages
+    )
+    assert not any("Traceback" in str(msg.get("content")) for msg in messages)
+
+
+def test_build_messages_normalizes_legacy_html_errors(monkeypatch):
+    monkeypatch.setattr("flowent.agent.get_settings", lambda: Settings())
+
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT), uuid="agent")
+    agent._append_history(
+        ErrorEntry(content="<html><body><pre>Internal Server Error</pre></body></html>")
+    )
+
+    messages = agent._build_messages()
+    serialized = json.dumps(messages)
+
+    assert "Upstream returned an unexpected error response" in serialized
+    assert "<html" not in serialized
+    assert "<pre>" not in serialized
+
+
+def test_build_messages_keeps_provider_error_text_in_context(monkeypatch):
+    monkeypatch.setattr("flowent.agent.get_settings", lambda: Settings())
+
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT), uuid="agent")
+    agent._append_history(ErrorEntry(content="LLMProviderError: provider offline"))
 
     messages = agent._build_messages()
 
     assert any(
         msg.get("role") == "user"
         and msg.get("content")
-        == "<system>Previous runtime error:\nRuntimeError: boom\n\ntraceback</system>"
+        == (
+            "<system>Previous runtime error:\n"
+            "LLMProviderError: provider offline</system>"
+        )
         for msg in messages
     )
 
 
+def test_unhandled_runtime_error_history_omits_traceback(monkeypatch):
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT, allow_network=True))
+    wait_calls = 0
+    chat_calls = 0
+
+    def fake_wait_for_input() -> None:
+        nonlocal wait_calls
+        wait_calls += 1
+        if wait_calls == 1:
+            agent._append_history(ReceivedMessage(content="start", from_id="human"))
+            agent.set_state(AgentState.RUNNING, "received message from human")
+            return
+        agent.request_termination("done")
+
+    def fake_chat(
+        messages,
+        tools=None,
+        on_chunk=None,
+        register_interrupt=None,
+        role_name=None,
+    ):
+        nonlocal chat_calls
+        chat_calls += 1
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(agent, "_wait_for_input", fake_wait_for_input)
+    monkeypatch.setattr("flowent.agent.gateway.chat", fake_chat)
+
+    agent._run()
+
+    assert chat_calls == 1
+    assert any(
+        isinstance(entry, ErrorEntry) and entry.content == "RuntimeError: boom"
+        for entry in agent.get_history_snapshot()
+    )
+    assert not any(
+        isinstance(entry, ErrorEntry) and "traceback" in entry.content.lower()
+        for entry in agent.get_history_snapshot()
+    )
+
+
 def test_assistant_emits_human_content_for_plain_text_with_target_like_prefix(
     monkeypatch,
 ):

package/backend/tests/unit/routes/test_prompts_routes.py

@@ -80,25 +80,3 @@ def test_update_prompts_allows_custom_post_prompt_only(monkeypatch):
         "custom_prompt": "Keep this.",
         "custom_post_prompt": "Append this after history.",
     }
-
-
-def test_update_prompts_accepts_legacy_post_prompt_alias(monkeypatch):
-    settings = Settings(custom_prompt="Keep this.", custom_post_prompt="")
-
-    monkeypatch.setattr("flowent.routes.prompts.get_settings", lambda: settings)
-    monkeypatch.setattr("flowent.routes.prompts.save_settings", lambda current: None)
-
-    result = asyncio.run(
-        update_prompts(
-            UpdatePromptSettingsRequest.model_validate(
-                {"post_prompt": "Append this after history."}
-            )
-        )
-    )
-
-    assert settings.custom_prompt == "Keep this."
-    assert settings.custom_post_prompt == "Append this after history."
-    assert result.model_dump() == {
-        "custom_prompt": "Keep this.",
-        "custom_post_prompt": "Append this after history.",
-    }