flowent 0.0.4 → 0.0.6

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

@@ -13,6 +13,7 @@ from flowent.agent import (
     WakeSignal,
 )
 from flowent.events import event_bus
+from flowent.graph_service import build_workflow_node_definition, create_edge
 from flowent.models import (
     AgentState,
     AssistantText,
@@ -28,17 +29,19 @@ from flowent.models import (
     NodeType,
     ReceivedMessage,
     SentMessage,
-    StateEntry,
     SystemEntry,
     Tab,
     TodoItem,
     ToolCall,
     ToolCallResult,
+    WorkflowActivationState,
+    WorkflowDefinition,
+    WorkflowNodeKind,
 )
+from flowent.observability_service import observability_store
 from flowent.providers.errors import LLMProviderError
 from flowent.registry import registry
 from flowent.settings import ModelSettings, ProviderConfig, Settings
-from flowent.stats_service import stats_store
 from flowent.workspace_store import workspace_store
 
 
@@ -52,16 +55,24 @@ def reset_runtime_state(monkeypatch, tmp_path):
     monkeypatch.setattr(settings_module, "_cached_settings", None)
     registry.reset()
     workspace_store.reset_cache()
-    stats_store.reset()
+    observability_store.reset()
     yield
     registry.reset()
     workspace_store.reset_cache()
-    stats_store.reset()
+    observability_store.reset()
     monkeypatch.setattr(settings_module, "_cached_settings", None)
 
 
 def _register_tab_leader(*, tab_id: str = "tab-1", leader_id: str = "leader") -> Agent:
-    workspace_store.upsert_tab(Tab(id=tab_id, title="Task", leader_id=leader_id))
+    workspace_store.upsert_tab(
+        Tab(
+            id=tab_id,
+            title="Task",
+            leader_id=leader_id,
+            allow_network=True,
+            permissions_initialized=True,
+        )
+    )
     leader = Agent(
         NodeConfig(
             node_type=NodeType.AGENT,
@@ -75,8 +86,41 @@ def _register_tab_leader(*, tab_id: str = "tab-1", leader_id: str = "leader") ->
     return leader
 
 
+def _add_agent_path(
+    *,
+    tab_id: str = "tab-1",
+    source_id: str,
+    target_id: str,
+) -> None:
+    tab = workspace_store.get_tab(tab_id)
+    assert tab is not None
+    existing = {node.id for node in tab.definition.nodes}
+    next_nodes = list(tab.definition.nodes)
+    for node_id in (source_id, target_id):
+        if node_id not in existing:
+            next_nodes.append(
+                build_workflow_node_definition(
+                    node_id=node_id,
+                    node_kind=WorkflowNodeKind.AGENT,
+                )
+            )
+    tab.definition = WorkflowDefinition(
+        version=tab.definition.version,
+        nodes=next_nodes,
+        edges=list(tab.definition.edges),
+        view=tab.definition.view,
+    )
+    workspace_store.upsert_tab(tab)
+    edge, error = create_edge(
+        tab_id=tab_id,
+        from_node_id=source_id,
+        to_node_id=target_id,
+    )
+    assert error is None and edge is not None
+
+
 def test_agent_keeps_running_after_pure_text_response(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT))
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT, allow_network=True))
     wait_calls = 0
     llm_messages: list[list[dict]] = []
     responses = iter([LLMResponse(content="working through the task"), LLMResponse()])
@@ -124,7 +168,7 @@ def test_agent_keeps_running_after_pure_text_response(monkeypatch):
 
 
 def test_agent_retries_transient_llm_errors_before_succeeding(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT))
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT, allow_network=True))
     wait_calls = 0
     llm_calls = 0
 
@@ -184,7 +228,15 @@ def test_agent_retries_transient_llm_errors_before_succeeding(monkeypatch):
 
 
 def test_chat_with_retries_records_single_request_stat(monkeypatch):
-    workspace_store.upsert_tab(Tab(id="tab-1", title="Task", leader_id="leader-1"))
+    workspace_store.upsert_tab(
+        Tab(
+            id="tab-1",
+            title="Task",
+            leader_id="leader-1",
+            allow_network=True,
+            permissions_initialized=True,
+        )
+    )
     agent = Agent(
         NodeConfig(
             node_type=NodeType.AGENT,
@@ -254,7 +306,7 @@ def test_chat_with_retries_records_single_request_stat(monkeypatch):
         tools_schema=None,
     )
 
-    records = stats_store.list_requests(since=0)
+    records = observability_store.list_requests(since=0)
 
     assert response.content == "Done"
     assert len(records) == 1
@@ -269,10 +321,67 @@ def test_chat_with_retries_records_single_request_stat(monkeypatch):
     assert records[0]["raw_usage"] == {"total_tokens": 120, "input_tokens": 90}
 
 
+def test_chat_with_retries_blocks_remote_model_when_network_is_disabled(monkeypatch):
+    workspace_store.upsert_tab(
+        Tab(
+            id="tab-1",
+            title="Task",
+            leader_id="leader-1",
+            allow_network=False,
+            permissions_initialized=True,
+        )
+    )
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            role_name="Worker",
+            name="Planner",
+            tab_id="tab-1",
+        ),
+        uuid="agent-1",
+    )
+    settings = Settings(
+        model=ModelSettings(
+            active_provider_id="provider-1",
+            active_model="gpt-5.2",
+        ),
+        providers=[
+            ProviderConfig(
+                id="provider-1",
+                name="Primary",
+                type="openai_responses",
+                base_url="https://api.example.com/v1",
+                api_key="secret",
+            )
+        ],
+    )
+    monkeypatch.setattr("flowent.agent.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.agent.gateway.chat",
+        lambda **kwargs: (_ for _ in ()).throw(
+            AssertionError("gateway should not be called")
+        ),
+    )
+
+    with pytest.raises(
+        LLMProviderError,
+        match="Network access is disabled for this workflow",
+    ):
+        agent._chat_with_retries(
+            prepared_context=PreparedLLMContext(
+                messages=[{"role": "user", "content": "hello"}],
+                system_messages=[],
+                execution_context_messages=[],
+                runtime_tail_messages=[],
+            ),
+            tools_schema=None,
+        )
+
+
 def test_agent_does_not_retry_transient_llm_errors_when_retry_policy_is_no_retry(
     monkeypatch,
 ):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT))
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT, allow_network=True))
     wait_calls = 0
     llm_calls = 0
 
@@ -325,7 +434,7 @@ def test_agent_does_not_retry_transient_llm_errors_when_retry_policy_is_no_retry
 
 
 def test_agent_does_not_retry_non_transient_llm_errors(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT))
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT, allow_network=True))
     wait_calls = 0
     llm_calls = 0
     error_summary = (
@@ -379,10 +488,8 @@ def test_agent_does_not_retry_non_transient_llm_errors(monkeypatch):
         isinstance(entry, ErrorEntry) and entry.content == error_summary
         for entry in agent.get_history_snapshot()
     )
-    assert any(
-        isinstance(entry, StateEntry)
-        and entry.state == AgentState.ERROR.value
-        and entry.reason == error_summary
+    assert all(
+        entry.__class__.__name__ != "StateEntry"
         for entry in agent.get_history_snapshot()
     )
     assert not any(
@@ -395,7 +502,7 @@ def test_agent_does_not_retry_non_transient_llm_errors(monkeypatch):
 
 
 def test_agent_interrupt_stops_retry_backoff(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT))
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT, allow_network=True))
     wait_calls = 0
     llm_calls = 0
     interrupter: threading.Thread | None = None
@@ -452,7 +559,7 @@ def test_agent_interrupt_stops_retry_backoff(monkeypatch):
 
 
 def test_agent_retries_transient_errors_when_retry_policy_is_unlimited(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT))
+    agent = Agent(NodeConfig(node_type=NodeType.AGENT, allow_network=True))
     wait_calls = 0
     llm_calls = 0
 
@@ -562,7 +669,15 @@ def test_get_llm_retry_429_delay_uses_active_provider_only_for_429(monkeypatch):
 
 
 def test_prepare_messages_records_auto_compact_stat(monkeypatch):
-    workspace_store.upsert_tab(Tab(id="tab-1", title="Task", leader_id="leader-1"))
+    workspace_store.upsert_tab(
+        Tab(
+            id="tab-1",
+            title="Task",
+            leader_id="leader-1",
+            allow_network=True,
+            permissions_initialized=True,
+        )
+    )
     agent = Agent(
         NodeConfig(
             node_type=NodeType.AGENT,
@@ -622,7 +737,7 @@ def test_prepare_messages_records_auto_compact_stat(monkeypatch):
     )
 
     result = agent._prepare_messages_for_llm()
-    records = stats_store.list_compacts(since=0)
+    records = observability_store.list_compacts(since=0)
 
     assert result == prepared_context
     assert compact_calls == [None]
@@ -654,8 +769,7 @@ def test_clear_assistant_chat_history_drops_conversation_entries():
     assistant.clear_chat_history()
 
     assert all(
-        isinstance(entry, (SystemEntry, StateEntry))
-        for entry in assistant.get_history_snapshot()
+        isinstance(entry, SystemEntry) for entry in assistant.get_history_snapshot()
     )
 
 
@@ -1001,7 +1115,7 @@ def test_execute_compact_command_replaces_history_with_summary(monkeypatch):
     assert "Summarize the rollout" not in serialized
     assert "Compacted execution context" in serialized
     assert "Ship the command layer." in serialized
-    assert "Compacted the current Assistant execution context." not in serialized
+    assert "Compacted this chat for future replies." not in serialized
 
 
 def test_compact_command_excludes_queued_messages_from_summary(monkeypatch):
@@ -1070,7 +1184,7 @@ def test_help_command_result_does_not_reenter_model_context():
     assert isinstance(entry, CommandResultEntry)
     assert entry.include_in_context is False
     assert "/compact" in entry.content
-    assert "Built-in Assistant commands" not in serialized
+    assert "Available commands" not in serialized
 
 
 def test_agent_normalizes_think_tags_in_final_content(monkeypatch):
@@ -1173,7 +1287,10 @@ def test_agent_dedupes_structured_thinking_and_raw_think_tags(monkeypatch):
 
 def test_agent_unregisters_from_registry_after_termination_request(monkeypatch):
     registry.reset()
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT), uuid="agent-x")
+    agent = Agent(
+        NodeConfig(node_type=NodeType.AGENT, allow_network=True),
+        uuid="agent-x",
+    )
     registry.register(agent)
     events = []
 
@@ -1435,11 +1552,7 @@ def test_request_sleep_wakes_early_when_new_message_arrives():
     ]
     assert len(received_entries) == 1
     assert received_entries[0].content == "wake up"
-    assert [
-        entry.state
-        for entry in agent.get_history_snapshot()
-        if isinstance(entry, StateEntry)
-    ][-2:] == ["sleeping", "running"]
+    assert all(entry.__class__.__name__ != "StateEntry" for entry in agent.history)
 
 
 def test_request_sleep_timeout_queues_deadline_notice():
@@ -1451,11 +1564,7 @@ def test_request_sleep_timeout_queues_deadline_notice():
     assert result.startswith("slept ")
     assert agent.state == AgentState.RUNNING
     assert agent._consume_runtime_notices() == [agent._build_sleep_deadline_notice()]
-    assert [
-        entry.state
-        for entry in agent.get_history_snapshot()
-        if isinstance(entry, StateEntry)
-    ][-2:] == ["sleeping", "running"]
+    assert all(entry.__class__.__name__ != "StateEntry" for entry in agent.history)
 
 
 def test_agent_interrupts_blocked_provider_without_streaming_output(monkeypatch):
@@ -1519,7 +1628,10 @@ def test_agent_interrupts_blocked_provider_without_streaming_output(monkeypatch)
 
 
 def test_provider_resolution_error_is_recorded_in_history(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT), uuid="agent-y")
+    agent = Agent(
+        NodeConfig(node_type=NodeType.AGENT, allow_network=True),
+        uuid="agent-y",
+    )
     wait_calls = 0
 
     def fake_wait_for_input() -> None:
@@ -1605,9 +1717,12 @@ def test_assistant_content_streams_even_when_response_has_tool_calls(monkeypatch
 
 def test_send_message_delivers_to_single_contact_and_records_histories(monkeypatch):
     registry.reset()
-    leader = _register_tab_leader()
+    _register_tab_leader()
     child = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="child")
+    peer = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="peer")
     registry.register(child)
+    registry.register(peer)
+    _add_agent_path(source_id="child", target_id="peer")
     events = []
 
     monkeypatch.setattr(event_bus, "emit", lambda event: events.append(event))
@@ -1615,7 +1730,9 @@ def test_send_message_delivers_to_single_contact_and_records_histories(monkeypat
     try:
         result = json.loads(
             child.send_message(
-                target_ref="leader",
+                target_ref="peer",
+                from_output_port_key="out",
+                to_input_port_key="in",
                 raw_parts=[{"type": "text", "text": "investigate the error"}],
             )
         )
@@ -1629,16 +1746,29 @@ def test_send_message_delivers_to_single_contact_and_records_histories(monkeypat
     )
     received_entry = next(
         entry
-        for entry in leader.get_history_snapshot()
+        for entry in peer.get_history_snapshot()
         if isinstance(entry, ReceivedMessage)
     )
-    signal = leader._wake_queue.get_nowait()
+    signal = peer._wake_queue.get_nowait()
 
-    assert result == {"status": "sent", "target_id": "leader"}
-    assert sent_entry.to_id == "leader"
+    assert result == {
+        "status": "sent",
+        "target_id": "peer",
+        "from_output_port_key": "out",
+        "to_input_port_key": "in",
+        "port_type": "parts",
+        "value_summary": "investigate the error",
+    }
+    assert sent_entry.to_id == "peer"
     assert sent_entry.content == "investigate the error"
+    assert sent_entry.from_output_port_key == "out"
+    assert sent_entry.to_input_port_key == "in"
+    assert sent_entry.value_summary == "investigate the error"
     assert received_entry.from_id == "child"
     assert received_entry.content == "investigate the error"
+    assert received_entry.from_output_port_key == "out"
+    assert received_entry.to_input_port_key == "in"
+    assert received_entry.value_summary == "investigate the error"
     assert sent_entry.message_id == received_entry.message_id
     assert signal.payload == {
         "message": {
@@ -1647,13 +1777,21 @@ def test_send_message_delivers_to_single_contact_and_records_histories(monkeypat
             "parts": [{"type": "text", "text": "investigate the error"}],
             "history_recorded": True,
             "message_id": sent_entry.message_id,
+            "from_output_port_key": "out",
+            "to_input_port_key": "in",
+            "port_type": "parts",
+            "value": [{"type": "text", "text": "investigate the error"}],
+            "value_summary": "investigate the error",
         }
     }
     assert [event.data for event in events if event.type == EventType.NODE_MESSAGE] == [
         {
-            "to_id": "leader",
+            "to_id": "peer",
             "content": "investigate the error",
             "message_id": sent_entry.message_id,
+            "from_output_port_key": "out",
+            "to_input_port_key": "in",
+            "port_type": "parts",
         }
     ]
 
@@ -1669,10 +1807,12 @@ def test_send_message_reports_error_when_target_is_not_in_contacts():
     try:
         with pytest.raises(
             ValueError,
-            match=r"Send failed: target `peer` is not in contacts\.",
+            match=r"Send failed: target `peer` is not connected from `out` to `in`\.",
         ):
             child.send_message(
                 target_ref="peer",
+                from_output_port_key="out",
+                to_input_port_key="in",
                 raw_parts=[{"type": "text", "text": "reply with the findings"}],
             )
     finally:
@@ -1690,10 +1830,12 @@ def test_send_message_validates_target_before_image_capability():
     try:
         with pytest.raises(
             ValueError,
-            match=r"Send failed: target `peer` is not in contacts\.",
+            match=r"Send failed: target `peer` is not connected from `out` to `in`\.",
         ):
             child.send_message(
                 target_ref="peer",
+                from_output_port_key="out",
+                to_input_port_key="in",
                 raw_parts=[{"type": "image", "asset_id": "asset-1"}],
             )
     finally:
@@ -1704,21 +1846,65 @@ def test_send_message_reports_error_when_target_lacks_input_image_support():
     registry.reset()
     _register_tab_leader()
     child = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="child")
+    peer = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="peer")
     registry.register(child)
+    registry.register(peer)
+    _add_agent_path(source_id="child", target_id="peer")
 
     try:
         with pytest.raises(
             ValueError,
-            match=r"Send failed: target `leader` does not support `input_image`\.",
+            match=r"Send failed: target `peer` does not support `input_image`\.",
         ):
             child.send_message(
-                target_ref="leader",
+                target_ref="peer",
+                from_output_port_key="out",
+                to_input_port_key="in",
                 raw_parts=[{"type": "image", "asset_id": "asset-1"}],
             )
     finally:
         registry.reset()
 
 
+def test_inactive_leader_cannot_send_work_to_agent_nodes():
+    registry.reset()
+    leader = _register_tab_leader()
+    worker = Agent(
+        NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1", name="Worker"),
+        uuid="worker",
+    )
+    registry.register(worker)
+
+    try:
+        with pytest.raises(
+            ValueError,
+            match=r"Activate this workflow before sending work to agent nodes\.",
+        ):
+            leader.send_message(
+                target_ref="worker",
+                raw_parts=[{"type": "text", "text": "start the task"}],
+            )
+        assert not any(
+            isinstance(entry, ReceivedMessage)
+            for entry in worker.get_history_snapshot()
+        )
+
+        tab = workspace_store.get_tab("tab-1")
+        assert tab is not None
+        tab.activation_state = WorkflowActivationState.ACTIVE
+        workspace_store.upsert_tab(tab)
+
+        result = json.loads(
+            leader.send_message(
+                target_ref="worker",
+                raw_parts=[{"type": "text", "text": "start the task"}],
+            )
+        )
+        assert result == {"status": "sent", "target_id": "worker"}
+    finally:
+        registry.reset()
+
+
 def test_record_content_output_treats_target_like_text_as_plain_output(monkeypatch):
     registry.reset()
     assistant = Agent(NodeConfig(node_type=NodeType.ASSISTANT), uuid="assistant")
@@ -1750,21 +1936,33 @@ def test_handle_tool_call_send_success_omits_toolcall_history(monkeypatch):
     registry.reset()
     _register_tab_leader()
     child = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="child")
+    peer = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="peer")
     registry.register(child)
+    registry.register(peer)
+    _add_agent_path(source_id="child", target_id="peer")
 
     try:
         result = child._handle_tool_call(
             "send",
             {
-                "target": "leader",
-                "parts": [{"type": "text", "text": "reply with the findings"}],
+                "target": "peer",
+                "from_output_port_key": "out",
+                "to_input_port_key": "in",
+                "value": [{"type": "text", "text": "reply with the findings"}],
             },
             "call-send",
         )
     finally:
         registry.reset()
 
-    assert json.loads(result) == {"status": "sent", "target_id": "leader"}
+    assert json.loads(result) == {
+        "status": "sent",
+        "target_id": "peer",
+        "from_output_port_key": "out",
+        "to_input_port_key": "in",
+        "port_type": "parts",
+        "value_summary": "reply with the findings",
+    }
     assert not any(
         isinstance(entry, ToolCall) and entry.tool_call_id == "call-send"
         for entry in child.get_history_snapshot()
@@ -1785,7 +1983,9 @@ def test_handle_tool_call_send_failure_records_error_without_toolcall():
             "send",
             {
                 "target": "peer",
-                "parts": [{"type": "text", "text": "reply with the findings"}],
+                "from_output_port_key": "out",
+                "to_input_port_key": "in",
+                "value": [{"type": "text", "text": "reply with the findings"}],
             },
             "call-send",
         )
@@ -1793,7 +1993,7 @@ def test_handle_tool_call_send_failure_records_error_without_toolcall():
         registry.reset()
 
     assert json.loads(result) == {
-        "error": "Send failed: target `peer` is not in contacts."
+        "error": "Send failed: target `peer` is not connected from `out` to `in`."
     }
     assert not any(
         isinstance(entry, ToolCall) and entry.tool_call_id == "call-send"
@@ -1801,18 +2001,22 @@ def test_handle_tool_call_send_failure_records_error_without_toolcall():
     )
     assert any(
         isinstance(entry, ErrorEntry)
-        and entry.content == "Send failed: target `peer` is not in contacts."
+        and entry.content
+        == "Send failed: target `peer` is not connected from `out` to `in`."
         for entry in child.get_history_snapshot()
     )
 
 
 def test_multiple_send_tool_calls_stop_after_first_failure(monkeypatch):
     registry.reset()
-    leader = _register_tab_leader()
+    _register_tab_leader()
     child = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="child")
+    peer = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="peer")
     helper = Agent(NodeConfig(node_type=NodeType.AGENT, tab_id="tab-1"), uuid="helper")
     registry.register(child)
+    registry.register(peer)
     registry.register(helper)
+    _add_agent_path(source_id="child", target_id="peer")
 
     wait_calls = 0
     chat_calls = 0
@@ -1842,8 +2046,10 @@ def test_multiple_send_tool_calls_stop_after_first_failure(monkeypatch):
                         id="call-send-1",
                         name="send",
                         arguments={
-                            "target": "leader",
-                            "parts": [{"type": "text", "text": "first"}],
+                            "target": "peer",
+                            "from_output_port_key": "out",
+                            "to_input_port_key": "in",
+                            "value": [{"type": "text", "text": "first"}],
                         },
                     ),
                     ToolCallResult(
@@ -1851,15 +2057,19 @@ def test_multiple_send_tool_calls_stop_after_first_failure(monkeypatch):
                         name="send",
                         arguments={
                             "target": "helper",
-                            "parts": [{"type": "text", "text": "second"}],
+                            "from_output_port_key": "out",
+                            "to_input_port_key": "in",
+                            "value": [{"type": "text", "text": "second"}],
                         },
                     ),
                     ToolCallResult(
                         id="call-send-3",
                         name="send",
                         arguments={
-                            "target": "leader",
-                            "parts": [{"type": "text", "text": "third"}],
+                            "target": "peer",
+                            "from_output_port_key": "out",
+                            "to_input_port_key": "in",
+                            "value": [{"type": "text", "text": "third"}],
                         },
                     ),
                 ]
@@ -1887,12 +2097,13 @@ def test_multiple_send_tool_calls_stop_after_first_failure(monkeypatch):
     assert [entry.content for entry in sent_entries] == ["first"]
     assert [
         entry.content
-        for entry in leader.get_history_snapshot()
+        for entry in peer.get_history_snapshot()
         if isinstance(entry, ReceivedMessage)
     ] == ["first"]
     assert helper._wake_queue.empty()
     assert any(
-        entry.content == "Send failed: target `helper` is not in contacts."
+        entry.content
+        == "Send failed: target `helper` is not connected from `out` to `in`."
         for entry in error_entries
     )
 
@@ -1914,7 +2125,7 @@ def test_build_messages_replays_sent_messages_as_message_to_context(monkeypatch)
         {"role": "assistant", "content": "final answer"},
         {
             "role": "user",
-            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send a formal message to another node, use `send` with a single `target` and ordered `parts`.\n- Use `contacts` to inspect the node ids and names you can currently message directly.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- If there is no unfinished TODO and the task is finished with no immediate next action, call `idle`.</system>",
+            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send through a workflow path, use `send` with one target, source output port, target input port, and a value matching that port type.\n- Use `contacts` to inspect the current output-port paths you can send through.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- If there is no unfinished TODO and the task is finished with no immediate next action, call `idle`.</system>",
         },
     ]
 
@@ -2126,7 +2337,7 @@ def test_build_messages_appends_runtime_todo_context_without_history_entry(monke
         },
         {
             "role": "user",
-            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send a formal message to another node, use `send` with a single `target` and ordered `parts`.\n- Use `contacts` to inspect the node ids and names you can currently message directly.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- If the TODO list is not complete yet, use `todo` to replace it with the latest remaining items.</system>",
+            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send through a workflow path, use `send` with one target, source output port, target input port, and a value matching that port type.\n- Use `contacts` to inspect the current output-port paths you can send through.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- If the TODO list is not complete yet, use `todo` to replace it with the latest remaining items.</system>",
         },
     ]
 
@@ -2154,7 +2365,7 @@ def test_build_messages_appends_runtime_post_prompt_and_idle_guidance(monkeypatc
         {"role": "user", "content": '<message from="human">begin</message>'},
         {
             "role": "user",
-            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send a formal message to another node, use `send` with a single `target` and ordered `parts`.\n- Use `contacts` to inspect the node ids and names you can currently message directly.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- If there is no unfinished TODO and the task is finished with no immediate next action, call `idle`.</system>",
+            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send through a workflow path, use `send` with one target, source output port, target input port, and a value matching that port type.\n- Use `contacts` to inspect the current output-port paths you can send through.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- If there is no unfinished TODO and the task is finished with no immediate next action, call `idle`.</system>",
         },
         {
             "role": "user",
@@ -2226,7 +2437,7 @@ def test_build_messages_warns_about_newly_created_agents_waiting_for_first_task(
         },
         {
             "role": "user",
-            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send a formal message to another node, use `send` with a single `target` and ordered `parts`.\n- Use `contacts` to inspect the node ids and names you can currently message directly.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- Newly created agents still waiting for their first task: Directory Worker (`12345678`).\n- `create_agent` only adds a new agent node to the current workflow. It does not start work by itself.\n- Before calling `idle`, dispatch each waiting agent a concrete first task with `send`.</system>",
+            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send through a workflow path, use `send` with one target, source output port, target input port, and a value matching that port type.\n- Use `contacts` to inspect the current output-port paths you can send through.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- Newly created agents still waiting for their first task: Directory Worker (`12345678`).\n- `create_agent` only adds a new agent node to the current workflow. It does not start work by itself.\n- Before calling `idle`, dispatch each waiting agent a concrete first task with `send`.</system>",
         },
     ]
 
@@ -2291,7 +2502,7 @@ def test_build_messages_uses_role_name_when_created_agent_has_no_explicit_name(
         },
         {
             "role": "user",
-            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send a formal message to another node, use `send` with a single `target` and ordered `parts`.\n- Use `contacts` to inspect the node ids and names you can currently message directly.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- Newly created agents still waiting for their first task: Worker (`12345678`).\n- `create_agent` only adds a new agent node to the current workflow. It does not start work by itself.\n- Before calling `idle`, dispatch each waiting agent a concrete first task with `send`.</system>",
+            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send through a workflow path, use `send` with one target, source output port, target input port, and a value matching that port type.\n- Use `contacts` to inspect the current output-port paths you can send through.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- Newly created agents still waiting for their first task: Worker (`12345678`).\n- `create_agent` only adds a new agent node to the current workflow. It does not start work by itself.\n- Before calling `idle`, dispatch each waiting agent a concrete first task with `send`.</system>",
         },
     ]
 
@@ -2367,7 +2578,7 @@ def test_build_messages_clears_new_agent_warning_after_first_sent_message(monkey
         },
         {
             "role": "user",
-            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send a formal message to another node, use `send` with a single `target` and ordered `parts`.\n- Use `contacts` to inspect the node ids and names you can currently message directly.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- If there is no unfinished TODO and the task is finished with no immediate next action, call `idle`.</system>",
+            "content": "<system>Runtime post prompt:\n- Plain content is never delivered to other agents.\n- To send through a workflow path, use `send` with one target, source output port, target input port, and a value matching that port type.\n- Use `contacts` to inspect the current output-port paths you can send through.\n- `@target:` or any other `@name:` text inside normal content is just text. It does not send anything.\n- If there is no unfinished TODO and the task is finished with no immediate next action, call `idle`.</system>",
         },
     ]
 
@@ -2525,7 +2736,9 @@ def test_assistant_emits_human_content_for_plain_text_with_target_like_prefix(
 
 
 def test_idle_tool_records_wakeup_message_as_new_input_block(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT, tools=["idle"]))
+    agent = Agent(
+        NodeConfig(node_type=NodeType.AGENT, tools=["idle"], allow_network=True)
+    )
     wait_calls = 0
     llm_messages: list[list[dict]] = []
     responses = iter(
@@ -2620,7 +2833,10 @@ def test_idle_tool_records_wakeup_message_as_new_input_block(monkeypatch):
 
 
 def test_agent_contextualizes_plain_loguru_calls(monkeypatch):
-    agent = Agent(NodeConfig(node_type=NodeType.AGENT), uuid="agent-z")
+    agent = Agent(
+        NodeConfig(node_type=NodeType.AGENT, allow_network=True),
+        uuid="agent-z",
+    )
     captured: list[tuple[str, str | None]] = []
     sink_id = logger.add(
         lambda message: captured.append(
@@ -2680,7 +2896,7 @@ def test_agent_denies_tool_call_before_edit_execute(monkeypatch, tmp_path):
         "call-edit",
     )
 
-    assert result == json.dumps({"error": "Write access is disabled for this agent"})
+    assert result == json.dumps({"error": "Write access is disabled for this workflow"})
     assert isinstance(agent.history[-1], ToolCall)
     assert agent.history[-1].result == result