machinaos 0.0.76 → 0.0.78

package/server/tests/nodes/test_email.py

@@ -27,7 +27,8 @@ pytestmark = pytest.mark.node_contract
 
 def _reset_singletons():
     """Wipe cached singletons so each test gets a clean EmailService / HimalayaService."""
-    from services import email_service, himalaya_service
+    from nodes.email import _service as email_service
+    from nodes.email import _himalaya as himalaya_service
 
     email_service.EmailService._instance = None
     himalaya_service.HimalayaService._instance = None
@@ -47,7 +48,7 @@ def _base_creds_params(**overrides):
 def _patch_ensure_binary():
     """Patch HimalayaService.ensure_binary to return a fake path without shutil.which."""
     return patch(
-        "services.himalaya_service.HimalayaService.ensure_binary",
+        "nodes.email._himalaya.HimalayaService.ensure_binary",
         new=AsyncMock(return_value="/usr/bin/himalaya"),
     )
 
@@ -91,7 +92,7 @@ class TestEmailSend:
         # Return empty JSON so himalaya "succeeds" with no extra fields
         with _patch_ensure_binary(), patched_subprocess(stdout=b"{}", returncode=0), \
              patched_container(auth_api_keys={"email_address": "alice@example.com", "email_password": "sekret", "email_provider": "gmail"}), patched_pricing(), \
-             patch("services.himalaya_service.HimalayaService.execute",
+             patch("nodes.email._himalaya.HimalayaService.execute",
                    new=AsyncMock(return_value={})) as mock_exec:
             result = await harness.execute(
                 "emailSend",
@@ -149,7 +150,7 @@ class TestEmailRead:
         ]
         # Himalaya returns a list for envelope list -> wrapped in {data: ...}
         with _patch_ensure_binary(), \
-             patch("services.himalaya_service.HimalayaService.execute",
+             patch("nodes.email._himalaya.HimalayaService.execute",
                    new=AsyncMock(return_value=envelopes)), \
              patched_container(auth_api_keys={"email_address": "alice@example.com", "email_password": "sekret", "email_provider": "gmail"}), patched_pricing():
             result = await harness.execute(
@@ -166,7 +167,7 @@ class TestEmailRead:
     async def test_read_merges_dict_output(self, harness):
         message = {"subject": "hello", "body": "world", "from": "a@x.com"}
         with _patch_ensure_binary(), \
-             patch("services.himalaya_service.HimalayaService.execute",
+             patch("nodes.email._himalaya.HimalayaService.execute",
                    new=AsyncMock(return_value=message)), \
              patched_container(auth_api_keys={"email_address": "alice@example.com", "email_password": "sekret", "email_provider": "gmail"}), patched_pricing():
             result = await harness.execute(
@@ -213,7 +214,7 @@ class TestEmailRead:
 class TestEmailReceive:
     async def test_new_email_detected_on_second_poll(self, harness):
         """Baseline sees {id1}; next poll returns {id1,id2} -> dispatch id2."""
-        from services.email_service import EmailService
+        from nodes.email._service import EmailService
 
         email_detail = {"from": "c@x.com", "subject": "new!", "body": "hi"}
 
@@ -248,8 +249,8 @@ class TestEmailReceive:
         assert dispatch_mock.call_args.args[0] == "email_received"
 
     async def test_mark_as_read_adds_seen_flag(self, harness):
-        from services.email_service import EmailService
-        from services.himalaya_service import HimalayaService
+        from nodes.email._service import EmailService
+        from nodes.email._himalaya import HimalayaService
 
         poll_ids_mock = AsyncMock(side_effect=[set(), {"42"}])
         fetch_detail_mock = AsyncMock(return_value={"message_id": "42", "folder": "INBOX"})
@@ -291,7 +292,7 @@ class TestEmailReceive:
 
     async def test_subprocess_error_surfaces_as_envelope(self, harness):
         """If poll_ids raises (e.g. Himalaya subprocess fails) the handler returns an error envelope."""
-        from services.email_service import EmailService
+        from nodes.email._service import EmailService
 
         poll_ids_mock = AsyncMock(side_effect=RuntimeError("himalaya error: connection refused"))
 

package/server/tests/nodes/test_google_workspace.py

@@ -42,10 +42,10 @@ def _patch_creds(module_name: str, creds_return=None, side_effect=None):
     By default returns a MagicMock that stands in for a Credentials instance.
     Pass `side_effect=ValueError(...)` to simulate missing credentials.
     """
-    # Scaling-branch: shared helper lives at services.handlers.google_auth.
+    # Scaling-branch: shared helper lives at nodes.google._auth_helper.
     # `module_name` is retained for API symmetry but not part of the patch path.
     _ = module_name
-    target = "services.handlers.google_auth.get_google_credentials"
+    target = "nodes.google._auth_helper.get_google_credentials"
     kwargs = {}
     if side_effect is not None:
         kwargs["side_effect"] = side_effect

package/server/tests/nodes/test_specialized_agents.py

@@ -463,73 +463,120 @@ class TestRLMAgent:
 
 
 class TestClaudeCodeAgent:
-    def _wire_claude_service(self, result_payload=None):
-        service = MagicMock(name="ClaudeCodeService")
-        service.execute = AsyncMock(
-            return_value=result_payload
-            or {
-                "result": "cli response",
-                "session_id": "sess-abc",
-                "usage": {"input_tokens": 10, "output_tokens": 5},
-            }
+    """The claude_code_agent plugin now goes through `AICliService.run_batch`
+    (multi-task batch). Single-prompt input gets adapted to a one-task batch
+    for back-compat. These tests mock the new service path."""
+
+    def _wire_cli_service(
+        self,
+        *,
+        response: str = "cli response",
+        session_id: str = "sess-abc",
+        cost_usd: float = 0.012,
+        success: bool = True,
+        error: str | None = None,
+    ):
+        """Mock `AICliService` with a `run_batch` that returns a one-task BatchResult."""
+        from services.cli_agent.protocol import (
+            BatchResult,
+            CanonicalUsage,
+            SessionResult,
         )
-        return service
 
-    async def test_happy_path_spawns_cli_and_returns_response(self, harness):
-        service = self._wire_claude_service()
+        async def fake_run_batch(provider, *, tasks, **kwargs):
+            tasks_list = list(tasks)
+            results = []
+            for t in tasks_list:
+                results.append(SessionResult(
+                    task_id=t.task_id or "t_test",
+                    session_id=session_id,
+                    provider=provider,
+                    prompt=t.prompt,
+                    response=response,
+                    cost_usd=cost_usd,
+                    duration_ms=1234,
+                    num_turns=2,
+                    canonical_usage=CanonicalUsage(input_tokens=10, output_tokens=5),
+                    success=success,
+                    error=error,
+                ))
+            n_succeeded = sum(1 for r in results if r.success)
+            return BatchResult(
+                tasks=results,
+                n_tasks=len(results),
+                n_succeeded=n_succeeded,
+                n_failed=len(results) - n_succeeded,
+                total_cost_usd=cost_usd if all(r.success for r in results) else None,
+                wall_clock_ms=1500,
+                provider=provider,
+                timestamp="2026-05-04T00:00:00Z",
+            )
+
+        svc = MagicMock(name="AICliService")
+        svc.run_batch = AsyncMock(side_effect=fake_run_batch)
+        svc.cancel_workflow = AsyncMock(return_value=0)
+        svc.cancel_node = AsyncMock(return_value=0)
+        return svc
+
+    async def test_happy_path_routes_through_run_batch(self, harness):
+        svc = self._wire_cli_service()
 
         with patched_container(auth_api_keys={}), patched_broadcaster(), patch(
-            "services.claude_code_service.get_claude_code_service",
-            return_value=service,
+            "services.cli_agent.service.get_ai_cli_service",
+            return_value=svc,
         ):
             result = await harness.execute(
                 "claude_code_agent",
                 {
                     "prompt": "write a hello world script",
                     "model": "claude-sonnet-4-6",
-                    "max_turns": 5,
-                    "max_budget_usd": 2.0,
                 },
             )
 
         harness.assert_envelope(result, success=True)
         payload = result["result"]
         assert payload["response"] == "cli response"
-        assert payload["provider"] == "anthropic"
         assert payload["session_id"] == "sess-abc"
-        assert payload["model"] == "claude-sonnet-4-6"
-
-        # The service was called with the documented kwargs.
-        call = service.execute.await_args
-        assert call.kwargs["model"] == "claude-sonnet-4-6"
-        assert call.kwargs["max_turns"] == 5
-        assert call.kwargs["max_budget_usd"] == 2.0
-        assert call.kwargs["prompt"] == "write a hello world script"
-
-    async def test_max_budget_usd_flag_is_passed_through(self, harness):
-        """Guards against the historical '--max-cost' bug: the handler must
-        forward maxBudgetUsd to the service as max_budget_usd."""
-        service = self._wire_claude_service()
+        assert payload["provider"] == "claude"
+        assert payload["n_tasks"] == 1
+        assert payload["n_succeeded"] == 1
+
+        # AICliService.run_batch was called with provider="claude" + 1 task
+        call = svc.run_batch.await_args
+        assert call.args[0] == "claude"
+        tasks = list(call.kwargs["tasks"])
+        assert len(tasks) == 1
+        assert tasks[0].prompt == "write a hello world script"
+        assert tasks[0].model == "claude-sonnet-4-6"
+
+    async def test_max_budget_usd_propagates_via_task_spec(self, harness):
+        """Per-task max_budget_usd must reach the ClaudeTaskSpec."""
+        svc = self._wire_cli_service()
 
         with patched_container(auth_api_keys={}), patched_broadcaster(), patch(
-            "services.claude_code_service.get_claude_code_service",
-            return_value=service,
+            "services.cli_agent.service.get_ai_cli_service",
+            return_value=svc,
         ):
             await harness.execute(
                 "claude_code_agent",
-                {"prompt": "x", "max_budget_usd": 7.5},
+                {
+                    "tasks": [
+                        {"prompt": "x", "provider": "claude", "max_budget_usd": 7.5},
+                    ],
+                },
             )
 
-        call = service.execute.await_args
-        assert call.kwargs["max_budget_usd"] == 7.5
+        call = svc.run_batch.await_args
+        tasks = list(call.kwargs["tasks"])
+        assert tasks[0].max_budget_usd == 7.5
 
     async def test_no_prompt_returns_failure(self, harness):
-        """Unique to claude_code_agent: explicit no-prompt short-circuit."""
-        service = self._wire_claude_service()
+        """No prompt + no tasks must short-circuit before constructing a batch."""
+        svc = self._wire_cli_service()
 
         with patched_container(auth_api_keys={}), patched_broadcaster(), patch(
-            "services.claude_code_service.get_claude_code_service",
-            return_value=service,
+            "services.cli_agent.service.get_ai_cli_service",
+            return_value=svc,
         ):
             result = await harness.execute(
                 "claude_code_agent",
@@ -538,18 +585,17 @@ class TestClaudeCodeAgent:
 
         harness.assert_envelope(result, success=False)
         assert "prompt" in result["error"].lower()
-        # CLI must not have been spawned.
-        assert service.execute.await_count == 0
+        # AICliService must not have been engaged.
+        assert svc.run_batch.await_count == 0
 
-    async def test_subprocess_failure_becomes_envelope(self, harness):
-        """When ClaudeCodeService.execute raises, the handler returns
-        success=false with the error message."""
-        service = MagicMock(name="ClaudeCodeService")
-        service.execute = AsyncMock(side_effect=RuntimeError("cli exit 1: boom"))
+    async def test_run_batch_failure_becomes_envelope(self, harness):
+        """When AICliService.run_batch raises, the handler surfaces the error."""
+        svc = MagicMock(name="AICliService")
+        svc.run_batch = AsyncMock(side_effect=RuntimeError("cli exit 1: boom"))
 
         with patched_container(auth_api_keys={}), patched_broadcaster(), patch(
-            "services.claude_code_service.get_claude_code_service",
-            return_value=service,
+            "services.cli_agent.service.get_ai_cli_service",
+            return_value=svc,
         ):
             result = await harness.execute(
                 "claude_code_agent",
@@ -560,7 +606,7 @@ class TestClaudeCodeAgent:
         assert "boom" in result["error"]
 
     async def test_auto_prompt_fallback_from_input_main(self, harness):
-        service = self._wire_claude_service()
+        svc = self._wire_cli_service()
 
         nodes = [
             {"id": "src-1", "type": "chatTrigger"},
@@ -576,8 +622,8 @@ class TestClaudeCodeAgent:
         )
 
         with patched_container(auth_api_keys={}), patched_broadcaster(), patch(
-            "services.claude_code_service.get_claude_code_service",
-            return_value=service,
+            "services.cli_agent.service.get_ai_cli_service",
+            return_value=svc,
         ):
             await harness.execute(
                 "claude_code_agent",
@@ -586,5 +632,6 @@ class TestClaudeCodeAgent:
                 context=ctx,
             )
 
-        call = service.execute.await_args
-        assert call.kwargs["prompt"] == "upstream text"
+        call = svc.run_batch.await_args
+        tasks = list(call.kwargs["tasks"])
+        assert tasks[0].prompt == "upstream text"

package/server/tests/nodes/test_stripe_plugin.py

@@ -0,0 +1,293 @@
+"""Contract tests for the Stripe plugin (Wave 12 framework version).
+
+The plugin is now a thin specialisation of ``services.events`` —
+``StripeListenSource`` (DaemonEventSource) supervises ``stripe listen``
+and ``StripeWebhookSource`` (WebhookSource) receives forwarded events.
+These tests verify the plugin wiring and the receive-node reshape;
+end-to-end smoke against the real CLI requires the binary on PATH.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import hmac
+import json
+import time
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+pytestmark = pytest.mark.node_contract
+
+
+def _run(coro):
+    return asyncio.new_event_loop().run_until_complete(coro)
+
+
+def _signed(body: bytes, secret: str) -> dict:
+    ts = int(time.time())
+    sig = hmac.new(secret.encode(), f"{ts}.".encode() + body, hashlib.sha256).hexdigest()
+    return {"Stripe-Signature": f"t={ts},v1={sig}"}
+
+
+def _fake_request(body: bytes, headers: dict | None = None):
+    """Return an object with the two attrs WebhookSource.handle uses."""
+
+    class R:
+        pass
+
+    r = R()
+    r.headers = headers or {}
+
+    async def _body():
+        return body
+
+    r.body = _body
+    return r
+
+
+# ============================================================================
+# StripeWebhookSource — shape() and end-to-end handle()
+# ============================================================================
+
+
+class TestStripeWebhookShape:
+    SECRET = "whsec_test_xyz"
+
+    def _stub_secret_resolution(self):
+        return patch(
+            "nodes.stripe._source.StripeCredential.resolve",
+            AsyncMock(return_value={"api_key": "sk_test", "stripe_webhook_secret": self.SECRET}),
+        )
+
+    def test_shape_extracts_stripe_fields(self):
+        from nodes.stripe._source import get_webhook_source
+        src = get_webhook_source()
+        payload = {
+            "id": "evt_1",
+            "type": "charge.succeeded",
+            "created": 1700000000,
+            "livemode": False,
+            "account": "acct_test",
+            "data": {"object": {"amount": 1000}},
+        }
+
+        class FakeReq:
+            headers = {}
+
+            async def body(self):
+                return b""
+
+        ev = _run(src.shape(FakeReq(), b"", payload))
+        assert ev.id == "evt_1"
+        assert ev.type == "stripe.charge.succeeded"
+        assert ev.source == "stripe://acct_test"
+        assert ev.data == {"object": {"amount": 1000}}
+
+    def test_handle_dispatches_on_valid_signature(self):
+        from nodes.stripe._source import get_webhook_source
+        src = get_webhook_source()
+        body = json.dumps({"id": "evt_2", "type": "charge.succeeded", "data": {}}).encode()
+        req = _fake_request(body, headers=_signed(body, self.SECRET))
+        with self._stub_secret_resolution(), \
+             patch("services.event_waiter.dispatch") as dispatch:
+            ev = _run(src.handle(req))
+        assert ev.type == "stripe.charge.succeeded"
+        dispatch.assert_called_once()
+        ev_type, dispatched = dispatch.call_args[0]
+        assert ev_type == "stripe.webhook"
+        assert dispatched.id == "evt_2"
+
+    def test_handle_rejects_tampered_signature(self):
+        from fastapi import HTTPException
+        from nodes.stripe._source import get_webhook_source
+        src = get_webhook_source()
+        body = json.dumps({"id": "evt_3", "type": "charge.succeeded"}).encode()
+        req = _fake_request(body, headers=_signed(body, "whsec_other"))
+        with self._stub_secret_resolution():
+            with pytest.raises(HTTPException) as exc:
+                _run(src.handle(req))
+        assert exc.value.status_code == 400
+
+
+# ============================================================================
+# StripeReceiveNode — filter + reshape
+# ============================================================================
+
+
+class TestStripeReceiveFilter:
+    def _filter(self, params: dict | None = None):
+        from nodes.stripe.stripe_receive import StripeReceiveNode, StripeReceiveParams
+        node = StripeReceiveNode()
+        return node.build_filter(StripeReceiveParams(**(params or {})))
+
+    def _ev(self, stripe_type: str, livemode: bool = False):
+        from services.events import WorkflowEvent
+        return WorkflowEvent(
+            source="stripe://acct_1",
+            type=f"stripe.{stripe_type}",
+            data={"livemode": livemode},
+        )
+
+    def test_all_matches_anything(self):
+        f = self._filter({"event_type_filter": "all"})
+        assert f(self._ev("charge.succeeded")) is True
+        assert f(self._ev("payment_intent.created")) is True
+
+    def test_exact_match(self):
+        f = self._filter({"event_type_filter": "charge.succeeded"})
+        assert f(self._ev("charge.succeeded")) is True
+        assert f(self._ev("charge.refunded")) is False
+
+    def test_wildcard_prefix(self):
+        f = self._filter({"event_type_filter": "charge.*"})
+        assert f(self._ev("charge.succeeded")) is True
+        assert f(self._ev("charge.refunded")) is True
+        assert f(self._ev("payment_intent.created")) is False
+
+    def test_livemode_filter(self):
+        live = self._filter({"livemode_filter": "live"})
+        test = self._filter({"livemode_filter": "test"})
+        assert live(self._ev("charge.succeeded", livemode=True)) is True
+        assert live(self._ev("charge.succeeded", livemode=False)) is False
+        assert test(self._ev("charge.succeeded", livemode=False)) is True
+        assert test(self._ev("charge.succeeded", livemode=True)) is False
+
+
+class TestStripeReceiveReshape:
+    def test_shape_output_extracts_stripe_fields(self):
+        from nodes.stripe.stripe_receive import StripeReceiveNode
+        from services.events import WorkflowEvent
+        ev = WorkflowEvent(
+            id="evt_1",
+            source="stripe://acct_42",
+            type="stripe.charge.succeeded",
+            data={
+                "request": {"id": "req_99"},
+                "data": {"object": {"amount": 2500}},
+                "livemode": True,
+                "api_version": "2024-04-10",
+            },
+        )
+        out = StripeReceiveNode().shape_output(ev)
+        assert out["event_id"] == "evt_1"
+        assert out["event_type"] == "charge.succeeded"
+        assert out["request_id"] == "req_99"
+        assert out["account"] == "acct_42"
+        assert out["livemode"] is True
+        assert out["data"] == {"object": {"amount": 2500}}
+
+
+# ============================================================================
+# StripeActionNode — pass-through over the CLI
+# ============================================================================
+
+
+class TestStripeActionPassthrough:
+    @pytest.fixture
+    def cli_capture(self):
+        captured: list[list[str]] = []
+
+        async def fake_run(*, binary, argv, **kwargs):
+            # Stripe CLI uses ~/.config/stripe/config.toml — no credential injection.
+            captured.append(list(argv))
+            return {"success": True, "result": {"id": "x"}, "stdout": "{}"}
+
+        return captured, fake_run
+
+    def test_command_is_shlex_split(self, cli_capture):
+        captured, fake = cli_capture
+        with patch("nodes.stripe.stripe_action.run_cli_command", AsyncMock(side_effect=fake)):
+            from nodes.stripe.stripe_action import StripeActionNode, StripeActionParams
+            node = StripeActionNode()
+            result = _run(node.run(None, StripeActionParams(command="customers create --email a@b.com")))
+            assert result["success"] is True
+            assert captured == [["customers", "create", "--email", "a@b.com"]]
+
+    def test_quoted_args_preserved(self, cli_capture):
+        captured, fake = cli_capture
+        with patch("nodes.stripe.stripe_action.run_cli_command", AsyncMock(side_effect=fake)):
+            from nodes.stripe.stripe_action import StripeActionNode, StripeActionParams
+            node = StripeActionNode()
+            _run(node.run(None, StripeActionParams(command="customers create --name 'Acme Inc'")))
+            assert captured == [["customers", "create", "--name", "Acme Inc"]]
+
+    def test_empty_command_raises(self):
+        from nodes.stripe.stripe_action import StripeActionNode, StripeActionParams
+        node = StripeActionNode()
+        with pytest.raises(RuntimeError, match="command is required"):
+            _run(node.run(None, StripeActionParams(command="   ")))
+
+    def test_cli_failure_raises(self):
+        from nodes.stripe.stripe_action import StripeActionNode, StripeActionParams
+
+        async def fake_fail(*, binary, argv, **kwargs):
+            return {"success": False, "error": "stripe: unknown command 'frobnicate'"}
+
+        with patch("nodes.stripe.stripe_action.run_cli_command", AsyncMock(side_effect=fake_fail)):
+            node = StripeActionNode()
+            with pytest.raises(RuntimeError, match="frobnicate"):
+                _run(node.run(None, StripeActionParams(command="frobnicate")))
+
+
+# ============================================================================
+# Plugin self-registration
+# ============================================================================
+
+
+class TestStripePluginRegistration:
+    def test_ws_handlers_registered(self):
+        import nodes.stripe  # noqa: F401
+        from services.ws_handler_registry import get_ws_handlers
+        registered = get_ws_handlers()
+        for name in (
+            "stripe_login", "stripe_logout",
+            "stripe_connect", "stripe_disconnect", "stripe_reconnect",
+            "stripe_status", "stripe_trigger",
+        ):
+            assert name in registered, f"WS handler '{name}' not registered"
+
+    def test_webhook_source_registered(self):
+        import nodes.stripe  # noqa: F401
+        from services.events import WEBHOOK_SOURCES
+        assert "stripe" in WEBHOOK_SOURCES
+        assert WEBHOOK_SOURCES["stripe"].type == "stripe.webhook"
+
+    def test_node_classes_registered(self):
+        import nodes.stripe  # noqa: F401
+        from services.node_registry import get_node_class
+        assert get_node_class("stripeReceive").__name__ == "StripeReceiveNode"
+        assert get_node_class("stripeAction").__name__ == "StripeActionNode"
+
+    def test_credential_registered(self):
+        import nodes.stripe  # noqa: F401
+        from services.plugin.credential import CREDENTIAL_REGISTRY
+        # Stripe CLI manages auth at ~/.config/stripe/config.toml; the
+        # credential class is a thin marker keyed by "stripe" (no api_key).
+        assert "stripe" in CREDENTIAL_REGISTRY
+
+    def test_output_schemas_registered(self):
+        import nodes.stripe  # noqa: F401
+        from services.node_output_schemas import NODE_OUTPUT_SCHEMAS
+        assert "stripeReceive" in NODE_OUTPUT_SCHEMAS
+        assert "stripeAction" in NODE_OUTPUT_SCHEMAS
+
+    def test_action_node_is_ai_tool(self):
+        from nodes.stripe.stripe_action import StripeActionNode
+        assert StripeActionNode.usable_as_tool is True
+
+    def test_receive_node_subscribes_to_stripe_webhook(self):
+        from nodes.stripe.stripe_receive import StripeReceiveNode
+        assert StripeReceiveNode.event_type == "stripe.webhook"
+
+    def test_listen_source_has_correct_namespace(self):
+        from nodes.stripe._source import get_listen_source
+        src = get_listen_source()
+        assert src.process_name == "stripe-listen"
+        assert src.workflow_namespace == "_stripe"
+        # Empty binary_name disables the framework's PATH check; the
+        # plugin resolves the binary itself via ensure_stripe_cli (which
+        # falls back to a workspace-local download on systems without
+        # a system install of the Stripe CLI).
+        assert src.binary_name == ""

package/server/tests/nodes/test_telegram_social.py

@@ -355,7 +355,7 @@ class TestSocialSend:
             return_value={"success": True, "message_id": "wamid.xyz"}
         )
 
-        with patch("services.whatsapp_service.handle_whatsapp_send", whatsapp_send):
+        with patch("nodes.whatsapp._service.handle_whatsapp_send", whatsapp_send):
             result = await harness.execute(
                 "socialSend",
                 {
@@ -385,7 +385,7 @@ class TestSocialSend:
         # recipientType=phone but no phone param -> ValueError inside handler
         whatsapp_send = AsyncMock()
 
-        with patch("services.whatsapp_service.handle_whatsapp_send", whatsapp_send):
+        with patch("nodes.whatsapp._service.handle_whatsapp_send", whatsapp_send):
             result = await harness.execute(
                 "socialSend",
                 {
@@ -404,7 +404,7 @@ class TestSocialSend:
         # Any non-whatsapp channel should surface as a failed envelope.
         whatsapp_send = AsyncMock()
 
-        with patch("services.whatsapp_service.handle_whatsapp_send", whatsapp_send):
+        with patch("nodes.whatsapp._service.handle_whatsapp_send", whatsapp_send):
             result = await harness.execute(
                 "socialSend",
                 {
@@ -425,7 +425,7 @@ class TestSocialSend:
             return_value={"success": False, "error": "rpc boom"}
         )
 
-        with patch("services.whatsapp_service.handle_whatsapp_send", whatsapp_send):
+        with patch("nodes.whatsapp._service.handle_whatsapp_send", whatsapp_send):
             result = await harness.execute(
                 "socialSend",
                 {

package/server/tests/nodes/test_twitter.py

@@ -242,7 +242,7 @@ class TestTwitterSend:
         with _patch_client(stub_cls), patched_container(
             auth_oauth_tokens=_ok_tokens()
         ), patched_pricing(), patch(
-            "services.twitter_oauth.TwitterOAuth"
+            "nodes.twitter._oauth.TwitterOAuth"
         ) as oauth_cls:
             oauth_instance = MagicMock()
             oauth_instance.refresh_access_token = refresh_mock

package/server/tests/nodes/test_web_automation.py

@@ -50,7 +50,7 @@ class _FakeBrowserService:
 
 def _patch_browser_service(svc):
     """Patch get_browser_service to return the fake."""
-    return patch("services.browser_service.get_browser_service", return_value=svc)
+    return patch("nodes.browser._service.get_browser_service", return_value=svc)
 
 
 # ============================================================================
@@ -140,7 +140,7 @@ class TestBrowser:
 
     async def test_service_not_installed(self, harness):
         with patch(
-            "services.browser_service.get_browser_service", return_value=None
+            "nodes.browser._service.get_browser_service", return_value=None
         ):
             result = await harness.execute("browser", {"operation": "navigate", "url": "https://x"})