machinaos 0.0.76 → 0.0.78

package/server/tests/services/memory/test_jsonl.py

@@ -0,0 +1,188 @@
+"""Coverage for ``services.memory.jsonl`` — parse / append / trim.
+
+Anthropic Messages API JSONL is the storage format the
+``claude_code_agent`` bridge round-trips. These tests pin the public
+contract: standard parsers ignore unknown metadata, append always
+emits a trailing newline, and trim returns removed lines verbatim for
+vector-store archival.
+"""
+
+from __future__ import annotations
+
+import json
+
+from langchain_core.messages import AIMessage, HumanMessage
+
+from services.memory.jsonl import append_message, parse_jsonl, trim_window
+from services.memory import (  # public re-exports
+    parse_jsonl as parse_jsonl_reexport,
+    append_message as append_message_reexport,
+    trim_window as trim_window_reexport,
+)
+
+
+# ---------------------------------------------------------------------------
+# parse_jsonl
+# ---------------------------------------------------------------------------
+
+
+def test_parse_jsonl_empty_input_returns_empty_list():
+    assert parse_jsonl("") == []
+    assert parse_jsonl(None) == []  # type: ignore[arg-type]
+
+
+def test_parse_jsonl_basic_user_assistant_pair():
+    text = (
+        '{"role": "user", "content": "hi"}\n'
+        '{"role": "assistant", "content": "hello"}\n'
+    )
+    msgs = parse_jsonl(text)
+    assert len(msgs) == 2
+    assert isinstance(msgs[0], HumanMessage) and msgs[0].content == "hi"
+    assert isinstance(msgs[1], AIMessage) and msgs[1].content == "hello"
+
+
+def test_parse_jsonl_skips_unparseable_lines_forward_compat():
+    text = (
+        '{"role": "user", "content": "ok"}\n'
+        "this is not json\n"
+        '{"role": "assistant", "content": "still ok"}\n'
+    )
+    msgs = parse_jsonl(text)
+    assert [m.content for m in msgs] == ["ok", "still ok"]
+
+
+def test_parse_jsonl_skips_unknown_roles():
+    text = (
+        '{"role": "system", "content": "unknown role"}\n'
+        '{"role": "tool_use", "content": "skipped"}\n'
+        '{"role": "user", "content": "kept"}\n'
+    )
+    msgs = parse_jsonl(text)
+    assert [m.content for m in msgs] == ["kept"]
+
+
+def test_parse_jsonl_collapses_content_blocks_to_text():
+    text = json.dumps({
+        "role": "assistant",
+        "content": [
+            {"type": "text", "text": "Got it"},
+            {"type": "tool_use", "id": "tu_1", "name": "search", "input": {}},
+            {"type": "text", "text": "blue."},
+        ],
+    }) + "\n"
+    msgs = parse_jsonl(text)
+    assert len(msgs) == 1
+    assert msgs[0].content == "Got it blue."  # text blocks joined; tool_use dropped
+
+
+def test_parse_jsonl_metadata_keys_are_ignored():
+    text = json.dumps({
+        "role": "user",
+        "content": "hi",
+        "timestamp": "2026-05-10T00:00:00Z",
+        "session_id": "abc-123",
+        "model": "claude",
+    }) + "\n"
+    msgs = parse_jsonl(text)
+    assert len(msgs) == 1 and msgs[0].content == "hi"
+
+
+# ---------------------------------------------------------------------------
+# append_message
+# ---------------------------------------------------------------------------
+
+
+def test_append_message_to_empty_string_yields_single_line_with_newline():
+    out = append_message("", "user", "hi")
+    assert out == '{"role": "user", "content": "hi"}\n'
+
+
+def test_append_message_chains_cleanly_across_calls():
+    text = ""
+    text = append_message(text, "user", "q1")
+    text = append_message(text, "assistant", "a1")
+    lines = [ln for ln in text.splitlines() if ln.strip()]
+    assert len(lines) == 2
+    assert json.loads(lines[0])["role"] == "user"
+    assert json.loads(lines[1])["role"] == "assistant"
+
+
+def test_append_message_normalises_missing_trailing_newline():
+    base = '{"role": "user", "content": "hi"}'  # no trailing newline
+    out = append_message(base, "assistant", "ok")
+    assert out.startswith('{"role": "user", "content": "hi"}\n')
+    assert out.endswith('"content": "ok"}\n')
+
+
+def test_append_message_metadata_round_trips_via_parse_jsonl():
+    text = append_message(
+        "", "assistant", "blue.",
+        timestamp="2026-05-10T12:34:56+00:00",
+        session_id="abc-123",
+        model="claude",
+    )
+    obj = json.loads(text.strip())
+    assert obj["timestamp"] == "2026-05-10T12:34:56+00:00"
+    assert obj["session_id"] == "abc-123"
+    assert obj["model"] == "claude"
+    # parse_jsonl still returns the message; metadata is preserved on the
+    # wire even if it's not surfaced on BaseMessage.
+    msgs = parse_jsonl(text)
+    assert msgs[0].content == "blue."
+
+
+def test_append_message_supports_non_ascii_content():
+    out = append_message("", "user", "héllo — 你好")
+    obj = json.loads(out.strip())
+    assert obj["content"] == "héllo — 你好"  # ensure_ascii=False preserves UTF-8
+
+
+# ---------------------------------------------------------------------------
+# trim_window
+# ---------------------------------------------------------------------------
+
+
+def test_trim_window_under_capacity_returns_input_unchanged_and_no_removed():
+    text = ""
+    text = append_message(text, "user", "q1")
+    text = append_message(text, "assistant", "a1")
+    trimmed, removed = trim_window(text, window_size=2)
+    assert trimmed == text
+    assert removed == []
+
+
+def test_trim_window_removes_oldest_pairs_first():
+    text = ""
+    text = append_message(text, "user", "q1")
+    text = append_message(text, "assistant", "a1")
+    text = append_message(text, "user", "q2")
+    text = append_message(text, "assistant", "a2")
+    text = append_message(text, "user", "q3")
+    text = append_message(text, "assistant", "a3")
+    trimmed, removed = trim_window(text, window_size=1)
+    # window=1 keeps last 2 lines; removes 4 oldest.
+    assert len(removed) == 4
+    kept = [json.loads(ln) for ln in trimmed.splitlines() if ln.strip()]
+    assert [k["content"] for k in kept] == ["q3", "a3"]
+    # Removed entries are returned verbatim so the vector store gets
+    # the raw JSONL line back.
+    removed_objs = [json.loads(ln) for ln in removed]
+    assert [o["content"] for o in removed_objs] == ["q1", "a1", "q2", "a2"]
+
+
+def test_trim_window_handles_empty_text():
+    trimmed, removed = trim_window("", 5)
+    assert trimmed == "" and removed == []
+
+
+# ---------------------------------------------------------------------------
+# Public-API re-exports through services.memory
+# ---------------------------------------------------------------------------
+
+
+def test_services_memory_reexports_match_jsonl_module():
+    """`services.memory.__init__` re-exports the JSONL public surface."""
+    assert parse_jsonl_reexport is parse_jsonl
+    assert append_message_reexport is append_message
+    assert trim_window_reexport is trim_window

package/server/tests/services/test_events.py

@@ -0,0 +1,333 @@
+"""Contract tests for the generalized event-source framework."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import hashlib
+import hmac
+import json
+import time
+from typing import Iterable
+from unittest.mock import patch
+
+import pytest
+
+pytestmark = pytest.mark.node_contract
+
+
+def _run(coro):
+    return asyncio.new_event_loop().run_until_complete(coro)
+
+
+# ============================================================================
+# WorkflowEvent envelope
+# ============================================================================
+
+
+class TestWorkflowEvent:
+    def test_required_fields(self):
+        from services.events import WorkflowEvent
+        ev = WorkflowEvent(source="stripe://acct_1", type="stripe.charge.succeeded")
+        assert ev.specversion == "1.0"
+        assert ev.id  # uuid default
+        assert ev.datacontenttype == "application/json"
+
+    def test_round_trip_json(self):
+        from services.events import WorkflowEvent
+        ev = WorkflowEvent(
+            source="stripe://acct_1", type="stripe.charge.succeeded", data={"amount": 1000},
+        )
+        restored = WorkflowEvent.model_validate(json.loads(ev.model_dump_json()))
+        assert restored.type == ev.type
+        assert restored.data == {"amount": 1000}
+        assert restored.id == ev.id
+
+    def test_matches_type_glob(self):
+        from services.events import WorkflowEvent
+        ev = WorkflowEvent(source="stripe://x", type="stripe.charge.succeeded")
+        assert ev.matches_type("all") is True
+        assert ev.matches_type("") is True
+        assert ev.matches_type("stripe.charge.succeeded") is True
+        assert ev.matches_type("stripe.charge.*") is True
+        assert ev.matches_type("stripe.*") is True
+        assert ev.matches_type("payment_intent.*") is False
+
+    def test_from_legacy(self):
+        from services.events import WorkflowEvent
+        ev = WorkflowEvent.from_legacy("whatsapp_message_received", {"text": "hi"})
+        assert ev.type == "whatsapp_message_received"
+        assert ev.data == {"text": "hi"}
+        assert ev.source.startswith("legacy://")
+
+
+# ============================================================================
+# Verifiers
+# ============================================================================
+
+
+class TestStripeVerifier:
+    SECRET = "whsec_test"
+
+    def _sign(self, body: bytes, ts: int | None = None) -> dict:
+        ts = ts if ts is not None else int(time.time())
+        signed = f"{ts}.".encode() + body
+        sig = hmac.new(self.SECRET.encode(), signed, hashlib.sha256).hexdigest()
+        return {"Stripe-Signature": f"t={ts},v1={sig}"}
+
+    def test_valid_signature_passes(self):
+        from services.events import StripeVerifier
+        body = b'{"id":"evt_1"}'
+        StripeVerifier.verify(self._sign(body), body, self.SECRET)
+
+    def test_tampered_body_rejected(self):
+        from services.events import StripeVerifier
+        body = b'{"id":"evt_1"}'
+        headers = self._sign(body)
+        with pytest.raises(ValueError):
+            StripeVerifier.verify(headers, b'{"id":"evt_2"}', self.SECRET)
+
+    def test_missing_header_rejected(self):
+        from services.events import StripeVerifier
+        with pytest.raises(ValueError, match="missing"):
+            StripeVerifier.verify({}, b'{}', self.SECRET)
+
+    def test_malformed_header_rejected(self):
+        from services.events import StripeVerifier
+        with pytest.raises(ValueError):
+            StripeVerifier.verify({"Stripe-Signature": "garbage"}, b'{}', self.SECRET)
+
+
+class TestGitHubVerifier:
+    def test_round_trip(self):
+        from services.events import GitHubVerifier
+        secret = "shh"
+        body = b'{"action":"opened"}'
+        sig = "sha256=" + hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
+        GitHubVerifier.verify({"X-Hub-Signature-256": sig}, body, secret)
+
+    def test_tampered_rejected(self):
+        from services.events import GitHubVerifier
+        with pytest.raises(ValueError):
+            GitHubVerifier.verify({"X-Hub-Signature-256": "sha256=deadbeef"}, b'{}', "shh")
+
+
+class TestStandardWebhooksVerifier:
+    def test_round_trip(self):
+        from services.events import StandardWebhooksVerifier
+        secret_raw = b"super-secret-key-bytes"
+        secret = "whsec_" + base64.b64encode(secret_raw).decode()
+        body = b'{"foo":"bar"}'
+        msg_id = "msg_abc"
+        ts = "1700000000"
+        signed = f"{msg_id}.{ts}.".encode() + body
+        sig = base64.b64encode(hmac.new(secret_raw, signed, hashlib.sha256).digest()).decode()
+        headers = {
+            "webhook-id": msg_id,
+            "webhook-timestamp": ts,
+            "webhook-signature": f"v1,{sig}",
+        }
+        StandardWebhooksVerifier.verify(headers, body, secret)
+
+    def test_tampered_rejected(self):
+        from services.events import StandardWebhooksVerifier
+        with pytest.raises(ValueError):
+            StandardWebhooksVerifier.verify(
+                {"webhook-id": "1", "webhook-timestamp": "1", "webhook-signature": "v1,bad"},
+                b'{}', "whsec_AAAA",
+            )
+
+
+class TestHmacVerifier:
+    def test_round_trip(self):
+        from services.events import HmacVerifier
+        secret = "shh"
+        body = b'{"x":1}'
+        sig = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
+        HmacVerifier.verify({"X-Signature-256": sig}, body, secret)
+
+
+# ============================================================================
+# PollingEventSource loop
+# ============================================================================
+
+
+class TestPollingEventSource:
+    def test_emits_what_poll_once_returns_then_sleeps(self):
+        from services.events import PollingEventSource, WorkflowEvent
+
+        class FakePolling(PollingEventSource):
+            type = "fake.polling"
+            poll_interval_default = 0  # tight loop for the test
+
+            def __init__(self):
+                super().__init__()
+                self.calls = 0
+
+            async def poll_once(self, state) -> Iterable[WorkflowEvent]:
+                self.calls += 1
+                if self.calls == 1:
+                    return [WorkflowEvent(source="x", type="fake.tick", data={"n": 1})]
+                self._stopped = True
+                return []
+
+        async def drain():
+            src = FakePolling()
+            seen = []
+            async for ev in src.emit():
+                seen.append(ev)
+                if len(seen) >= 1:
+                    src._stopped = True
+            return seen
+
+        events = _run(drain())
+        assert len(events) == 1
+        assert events[0].type == "fake.tick"
+
+
+# ============================================================================
+# WebhookSource — handle() integration
+# ============================================================================
+
+
+class TestWebhookSourceHandle:
+    def _build_source(self, secret_value: str | None):
+        from services.events import StripeVerifier, WebhookSource, WorkflowEvent
+
+        class _Cred:
+            @classmethod
+            async def resolve(cls):
+                if secret_value is None:
+                    raise PermissionError
+                return {"api_key": "sk_test", "test_secret": secret_value}
+
+        class FakeSource(WebhookSource):
+            type = "fake.hook"
+            path = "fake"
+            verifier = StripeVerifier
+            secret_field = "test_secret"
+            credential = _Cred
+
+            async def shape(self, request, body, payload):
+                return WorkflowEvent(source="fake://x", type="fake.event", data=payload)
+
+        return FakeSource()
+
+    def _signed_request(self, body: bytes, secret: str):
+        ts = int(time.time())
+        signed = f"{ts}.".encode() + body
+        sig = hmac.new(secret.encode(), signed, hashlib.sha256).hexdigest()
+
+        class FakeReq:
+            headers = {"Stripe-Signature": f"t={ts},v1={sig}"}
+
+            async def body(self):
+                return body
+
+        return FakeReq()
+
+    def test_valid_signature_dispatches(self):
+        src = self._build_source(secret_value="whsec_test")
+        body = b'{"event":"payload"}'
+        req = self._signed_request(body, "whsec_test")
+        with patch("services.event_waiter.dispatch") as dispatch:
+            ev = _run(src.handle(req))
+        assert ev.type == "fake.event"
+        dispatch.assert_called_once()
+        called_type, called_event = dispatch.call_args[0]
+        assert called_type == "fake.hook"
+        assert called_event is ev
+
+    def test_tampered_signature_raises_400(self):
+        from fastapi import HTTPException
+        src = self._build_source(secret_value="whsec_test")
+        body = b'{"event":"payload"}'
+        req = self._signed_request(body, "whsec_other")  # signed with different secret
+        with pytest.raises(HTTPException) as exc:
+            _run(src.handle(req))
+        assert exc.value.status_code == 400
+
+    def test_missing_secret_accepts_unverified(self):
+        """No secret captured yet -> log warning, accept event."""
+        src = self._build_source(secret_value=None)
+        body = b'{"event":"payload"}'
+
+        class FakeReq:
+            headers = {}
+
+            async def body(self):
+                return body
+
+        with patch("services.event_waiter.dispatch") as dispatch:
+            ev = _run(src.handle(FakeReq()))
+        assert ev.type == "fake.event"
+        dispatch.assert_called_once()
+
+
+# ============================================================================
+# DaemonEventSource lifecycle (mocked ProcessService)
+# ============================================================================
+
+
+class TestDaemonEventSource:
+    def test_start_calls_process_service_start(self):
+        from services.events import DaemonEventSource
+
+        class FakeDaemon(DaemonEventSource):
+            type = "fake.daemon"
+            process_name = "fake-daemon"
+            binary_name = "echo"  # always on PATH
+
+            def build_command(self, secrets):
+                return "echo hello"
+
+            def parse_line(self, stream, line):
+                return None
+
+        async def go():
+            with patch("services.events.daemon.shutil.which", return_value="/usr/bin/echo"), \
+                 patch("services.events.daemon.get_process_service") as get_ps:
+                ps = get_ps.return_value
+
+                async def fake_start(**kwargs):
+                    return {"success": True, "result": {"pid": 4242}}
+
+                ps.start.side_effect = fake_start
+
+                async def fake_stop(**kwargs):
+                    return {"success": True}
+
+                ps.stop.side_effect = fake_stop
+
+                src = FakeDaemon()
+                result = await src.start()
+                assert result["success"] is True
+                assert src.pid == 4242
+                ps.start.assert_called_once()
+                # Cancel the tail task so the test exits cleanly.
+                await src.stop()
+                assert src.pid is None
+
+        _run(go())
+
+    def test_start_fails_when_binary_missing(self):
+        from services.events import DaemonEventSource
+
+        class FakeDaemon(DaemonEventSource):
+            type = "fake.daemon"
+            process_name = "fake-daemon"
+            binary_name = "definitely-not-on-path-zzzzz"
+            install_hint = "see docs"
+
+            def build_command(self, secrets):
+                return "x"
+
+        async def go():
+            with patch("services.events.daemon.shutil.which", return_value=None):
+                src = FakeDaemon()
+                result = await src.start()
+                assert result["success"] is False
+                assert "PATH" in result["error"]
+                assert "see docs" in result["error"]
+
+        _run(go())

package/server/tests/test_node_spec.py

@@ -1,9 +1,10 @@
 """Wave 6 NodeSpec contract tests.
 
 Locks in the public shape emitted by services/node_input_schemas.py,
-services/node_spec.py, services/node_option_loaders, and the
-/api/schemas/nodes/*/spec.json + /api/schemas/nodes/options/* endpoints.
-Mirrors the Wave 3 test posture for node_output_schemas.
+services/node_spec.py, services/ws_handler_registry (option-loader
+registry, post-Wave-11.I M.3), and the /api/schemas/nodes/*/spec.json +
+/api/schemas/nodes/options/* endpoints. Mirrors the Wave 3 test posture
+for node_output_schemas.
 """
 
 import pytest  # noqa: F401  (used by @pytest.mark.asyncio on Phase 4 tests)
@@ -16,6 +17,19 @@ from services.node_input_schemas import (
 from services.node_spec import get_node_spec, list_node_types_with_spec
 
 
+def _numeric_constraints(prop: dict) -> dict:
+    """Pydantic emits ``Optional[float] = Field(ge=..., le=...)`` as
+    ``{anyOf: [{number, minimum, maximum}, {null}]}``. This helper digs
+    out the numeric branch so tests don't have to special-case nullable
+    vs. required fields each time we tweak Params."""
+    if "minimum" in prop or "maximum" in prop:
+        return prop
+    for branch in prop.get("anyOf", ()):
+        if branch.get("type") == "number" or "minimum" in branch or "maximum" in branch:
+            return branch
+    return prop
+
+
 class TestInputSchemas:
     def test_registry_not_empty(self):
         assert len(NODE_INPUT_MODELS) > 50
@@ -35,8 +49,9 @@ class TestInputSchemas:
         schema = get_node_input_schema("aiAgent")
         assert schema is not None
         props = schema["properties"]
-        assert props["temperature"]["minimum"] == 0.0
-        assert props["temperature"]["maximum"] == 2.0
+        temp = _numeric_constraints(props["temperature"])
+        assert temp["minimum"] == 0.0
+        assert temp["maximum"] == 2.0
         # snake_case keys per Wave 11.E.4+ convention.
         # NB: ``api_key`` is NOT a declared field — credentials live in
         # the credentials DB and are auto-injected at execution time.
@@ -237,7 +252,7 @@ class TestPhase3cCoverage:
         # All 16 specialized agents share SpecializedAgentParams - constraints
         # like temperature 0-2 should appear identically.
         spec = get_node_spec("coding_agent")
-        temp = spec["inputs"]["properties"]["temperature"]
+        temp = _numeric_constraints(spec["inputs"]["properties"]["temperature"])
         assert temp["minimum"] == 0.0
         assert temp["maximum"] == 2.0
 
@@ -372,31 +387,33 @@ class TestPhase4LoadOptions:
     """Wave 6 Phase 4: unified loadOptionsMethod dispatch registry."""
 
     def test_registry_has_whatsapp_methods(self):
-        from services.node_option_loaders import LOAD_OPTIONS_REGISTRY
+        from services.ws_handler_registry import list_load_options_methods
+        methods = list_load_options_methods()
         for method in ["whatsappGroups", "whatsappChannels", "whatsappGroupMembers"]:
-            assert method in LOAD_OPTIONS_REGISTRY
+            assert method in methods
 
     def test_registry_has_google_methods(self):
-        from services.node_option_loaders import LOAD_OPTIONS_REGISTRY
+        from services.ws_handler_registry import list_load_options_methods
+        methods = list_load_options_methods()
         for method in ["gmailLabels", "googleCalendarList", "googleDriveFolders", "googleTasklists"]:
-            assert method in LOAD_OPTIONS_REGISTRY
+            assert method in methods
 
     def test_list_methods_sorted(self):
-        from services.node_option_loaders import list_load_options_methods
+        from services.ws_handler_registry import list_load_options_methods
         methods = list_load_options_methods()
         assert methods == sorted(methods)
         assert len(methods) >= 7
 
     @pytest.mark.asyncio
     async def test_unknown_method_returns_empty(self):
-        from services.node_option_loaders import dispatch_load_options
+        from services.ws_handler_registry import dispatch_load_options
         result = await dispatch_load_options("nonExistentMethodXyz", {})
         assert result == []
 
     @pytest.mark.asyncio
     async def test_dispatch_passes_params(self):
         # Smoke test: unknown method tolerates arbitrary params, doesn't crash
-        from services.node_option_loaders import dispatch_load_options
+        from services.ws_handler_registry import dispatch_load_options
         result = await dispatch_load_options("unknown", {"group_id": "abc"})
         assert result == []
 
@@ -730,17 +747,19 @@ class TestNodeSpecContractInvariants:
 
     def test_load_options_methods_are_registered(self):
         """Every Pydantic Field(loadOptionsMethod=X) must point at a
-        method registered in LOAD_OPTIONS_REGISTRY. Catches typos and
+        registered loader -- either in the legacy table or in a
+        plugin's ``register_option_loader`` call. Catches typos and
         forgotten loader registrations."""
         from services.node_input_schemas import get_node_input_schema, NODE_INPUT_MODELS
-        from services.node_option_loaders import LOAD_OPTIONS_REGISTRY
+        from services.ws_handler_registry import list_load_options_methods
+        methods = set(list_load_options_methods())
         for t in NODE_INPUT_MODELS:
             schema = get_node_input_schema(t)
             for prop_name, prop in schema.get("properties", {}).items():
                 method = prop.get("loadOptionsMethod")
                 if method is None:
                     continue
-                assert method in LOAD_OPTIONS_REGISTRY, (
+                assert method in methods, (
                     f"{t}.{prop_name} references unknown loadOptionsMethod {method!r}"
                 )
 
@@ -777,6 +796,11 @@ class TestNodeSpecContractInvariants:
             "width", "height",
             # Wave 10.G.5: start-node's user-authored JSON blob marker
             "hasInitialDataBlob",
+            # Auto-derived from group membership ('memory' / 'tool') by
+            # _derive_auto_ui_hints in services/plugin/base.py. Tells the
+            # parameter panel that this node is an auxiliary config node
+            # and should inherit the parent's main inputs.
+            "isConfigNode",
         }
         for node_type, meta in NODE_METADATA.items():
             hints = meta.get("uiHints") or {}
@@ -882,10 +906,26 @@ class TestPluginContractInvariants:
     def test_hide_output_handle_nodes_really_have_no_output(self):
         # If a node advertises hideOutputHandle=True, it shouldn't also
         # declare an output in its handles list — inconsistent.
+        # Exception: tool-oriented nodes (component_kind="tool" pure
+        # ToolNodes, or ActionNode + usable_as_tool=True dual-use nodes)
+        # have hide_output_handle auto-derived True via
+        # BaseNode.__init_subclass__. Their declared handles tuple still
+        # carries output-tool / output-main for backend awareness, but
+        # the SquareNode frontend suppresses the default render. The
+        # invariant's original intent was "explicit author intent should
+        # be consistent" — auto-derived is not author intent, so skip
+        # those nodes.
+        from services.node_registry import get_node_class
         for t in self._plugin_types():
             spec = get_node_spec(t)
             if not spec.get("hideOutputHandle"):
                 continue
+            cls = get_node_class(t)
+            if cls is not None and (
+                getattr(cls, "usable_as_tool", False)
+                or getattr(cls, "component_kind", "") == "tool"
+            ):
+                continue
             outs = [h for h in spec.get("handles") or [] if h.get("kind") == "output"]
             assert not outs, (
                 f"{t}: hideOutputHandle=True but handles declares output(s) {outs}"