feat(matrix-bridge-dagi): add egress, audit integration, fix router endpoint (PR-M1.4)

Closes the full Matrix ↔ DAGI loop:

Egress:
- invoke Router POST /v1/agents/{agent_id}/infer (field: prompt, response: response)
- send_text() reply to Matrix room with idempotent txn_id = make_txn_id(room_id, event_id)
- empty reply → skip send (no spam)
- reply truncated to 4000 chars if needed

Audit (via sofiia-console POST /api/audit/internal):
- matrix.message.received (on ingress)
- matrix.agent.replied (on successful reply)
- matrix.error (on router/send failure, with error_code)
- fire-and-forget: audit failures never crash the loop

Router URL fix:
- DAGI_GATEWAY_URL now points to dagi-router-node1:8000 (not gateway:9300)
- Session ID: stable per room — matrix:{room_localpart} (memory context)

9 tests: invoke endpoint, fallback fields, audit write, full cycle,
dedupe, empty reply skip, metric callbacks

Made-with: Cursor

tests/test_matrix_bridge_ingress.py

@@ -1,11 +1,13 @@
 """
-Tests for services/matrix-bridge-dagi/app/ingress.py
+Tests for services/matrix-bridge-dagi/app/ingress.py (M1.4 — egress + audit)
 
 Strategy:
-  - mock MatrixClient.sync_poll and extract_room_messages
-  - mock httpx gateway client
-  - verify gateway is invoked once per unique message (dedupe works)
-  - verify stop_event terminates loop
+  - mock MatrixClient sync_poll / send_text
+  - mock httpx client for router invoke and audit write
+  - verify: gateway invoked, send_text called with correct args
+  - verify: dedupe prevents double-invoke
+  - verify: audit events fire (received, replied, error)
+  - verify: empty reply skips send_text (no spam)
 """
 
 import asyncio
@@ -20,7 +22,7 @@ _BRIDGE = Path(__file__).parent.parent / "services" / "matrix-bridge-dagi"
 if str(_BRIDGE) not in sys.path:
     sys.path.insert(0, str(_BRIDGE))
 
-from app.ingress import MatrixIngressLoop, _invoke_gateway  # noqa: E402
+from app.ingress import MatrixIngressLoop, _invoke_router, _write_audit  # noqa: E402
 from app.room_mapping import parse_room_map  # noqa: E402
 
 
@@ -31,27 +33,22 @@ def run(coro):
 ALLOWED = frozenset({"sofiia"})
 ROOM_ID = "!QwHczWXgefDHBEVkTH:daarion.space"
 ROOM_MAP_STR = f"sofiia:{ROOM_ID}"
-GW_URL = "http://127.0.0.1:9300"
-HS_URL = "http://localhost:8008"
+ROUTER_URL = "http://dagi-router-node1:8000"
+HS_URL = "http://dagi-synapse-node1:8008"
+CONSOLE_URL = "http://dagi-sofiia-console-node1:8002"
+INTERNAL_TOKEN = "test_internal_token_xyz"
 TOKEN = "syt_fake_token"
 BOT_USER = "@dagi_bridge:daarion.space"
+USER = "@user:daarion.space"
 
-MOCK_EVENT_1 = {
+MSG_EVENT = {
     "type": "m.room.message",
     "event_id": "$event1:server",
-    "sender": "@user:server",
-    "content": {"msgtype": "m.text", "body": "Hello Sofiia!"},
+    "sender": USER,
+    "content": {"msgtype": "m.text", "body": "Привіт Sofiia!"},
     "origin_server_ts": 1000,
 }
 
-MOCK_EVENT_2 = {
-    "type": "m.room.message",
-    "event_id": "$event2:server",
-    "sender": "@user:server",
-    "content": {"msgtype": "m.text", "body": "Another message"},
-    "origin_server_ts": 2000,
-}
-
 
 def _make_loop(**kwargs) -> MatrixIngressLoop:
     room_map = parse_room_map(ROOM_MAP_STR, ALLOWED)
@@ -59,208 +56,349 @@ def _make_loop(**kwargs) -> MatrixIngressLoop:
         matrix_homeserver_url=HS_URL,
         matrix_access_token=TOKEN,
         matrix_user_id=BOT_USER,
-        gateway_url=GW_URL,
+        router_url=ROUTER_URL,
         node_id="NODA1",
         room_map=room_map,
+        sofiia_console_url=CONSOLE_URL,
+        sofiia_internal_token=INTERNAL_TOKEN,
     )
     defaults.update(kwargs)
     return MatrixIngressLoop(**defaults)
 
 
-def _fake_sync_resp(events: list) -> dict:
+def _fake_sync(events: list) -> dict:
     return {
         "next_batch": "s_next",
-        "rooms": {
-            "join": {
-                ROOM_ID: {
-                    "timeline": {"events": events}
-                }
-            }
-        }
+        "rooms": {"join": {ROOM_ID: {"timeline": {"events": events}}}},
     }
 
 
-# ── _invoke_gateway ─────────────────────────────────────────────────────────
+def _ok_response(text: str = "Привіт! Я тут.") -> MagicMock:
+    resp = MagicMock()
+    resp.status_code = 200
+    resp.json.return_value = {"response": text, "model": "test", "tokens_used": 100}
+    resp.raise_for_status = MagicMock()
+    return resp
 
-def test_invoke_gateway_builds_correct_request():
+
+def _audit_response() -> MagicMock:
+    resp = MagicMock()
+    resp.status_code = 200
+    resp.json.return_value = {"ok": True}
+    resp.raise_for_status = MagicMock()
+    return resp
+
+
+def _send_text_response() -> MagicMock:
+    resp = MagicMock()
+    resp.status_code = 200
+    resp.json.return_value = {"event_id": "$reply:server"}
+    resp.raise_for_status = MagicMock()
+    return resp
+
+
+# ── _invoke_router ─────────────────────────────────────────────────────────────
+
+def test_invoke_router_correct_endpoint_and_field():
     async def _inner():
         captured = {}
 
         async def fake_post(url, *, json=None, timeout=None):
             captured["url"] = url
-            captured["json"] = json
+            captured["payload"] = json
+            return _ok_response("pong!")
+
+        client = MagicMock()
+        client.post = fake_post
+        result = await _invoke_router(client, ROUTER_URL, "sofiia", "NODA1", "ping", "session-1")
+
+        assert "/v1/agents/sofiia/infer" in captured["url"]
+        assert captured["payload"]["prompt"] == "ping"
+        assert captured["payload"]["session_id"] == "session-1"
+        assert result == "pong!"
+    run(_inner())
+
+
+def test_invoke_router_fallback_fields():
+    """Should pick up text/content/message if response key missing."""
+    async def _inner():
+        async def fake_post(url, *, json=None, timeout=None):
             resp = MagicMock()
             resp.status_code = 200
-            resp.json.return_value = {"ok": True}
+            resp.json.return_value = {"text": "hello from text field"}
             resp.raise_for_status = MagicMock()
             return resp
 
         client = MagicMock()
         client.post = fake_post
-        result = await _invoke_gateway(
-            client, GW_URL, "sofiia", "NODA1",
-            "Hello!", ROOM_ID, "$event1", "@user:server"
-        )
-
-        assert "/v1/invoke" in captured["url"]
-        payload = captured["json"]
-        assert payload["agent_id"] == "sofiia"
-        assert payload["node_id"] == "NODA1"
-        assert payload["message"] == "Hello!"
-        meta = payload["metadata"]
-        assert meta["transport"] == "matrix"
-        assert meta["matrix_room_id"] == ROOM_ID
-        assert meta["matrix_event_id"] == "$event1"
-        assert meta["matrix_sender"] == "@user:server"
-
+        result = await _invoke_router(client, ROUTER_URL, "sofiia", "NODA1", "hi", "s1")
+        assert result == "hello from text field"
     run(_inner())
 
 
-# ── Ingress loop — normal flow ──────────────────────────────────────────────
+# ── _write_audit ───────────────────────────────────────────────────────────────
 
-def test_ingress_loop_invokes_gateway_once_per_message():
+def test_write_audit_fires_to_console():
     async def _inner():
-        received_calls: List[Dict] = []
+        captured = {}
 
-        async def fake_post(url, *, json=None, timeout=None):
-            received_calls.append({"url": url, "json": json})
-            resp = MagicMock()
-            resp.status_code = 200
-            resp.json.return_value = {"ok": True}
-            resp.raise_for_status = MagicMock()
-            return resp
+        async def fake_post(url, *, json=None, headers=None, timeout=None):
+            captured["url"] = url
+            captured["headers"] = headers
+            captured["json"] = json
+            return _audit_response()
+
+        client = MagicMock()
+        client.post = fake_post
+
+        await _write_audit(
+            client, CONSOLE_URL, INTERNAL_TOKEN,
+            event="matrix.message.received",
+            agent_id="sofiia", node_id="NODA1",
+            room_id=ROOM_ID, event_id="$e1",
+            status="ok",
+        )
+        assert "/api/audit/internal" in captured["url"]
+        assert captured["headers"]["X-Internal-Service-Token"] == INTERNAL_TOKEN
+        assert captured["json"]["event"] == "matrix.message.received"
+    run(_inner())
+
+
+def test_write_audit_no_op_when_no_token():
+    async def _inner():
+        called = [False]
+
+        async def fake_post(*args, **kwargs):
+            called[0] = True
+            return _audit_response()
+
+        client = MagicMock()
+        client.post = fake_post
+        # Empty token — should not call
+        await _write_audit(client, CONSOLE_URL, "", "matrix.test", "sofiia", "NODA1", ROOM_ID, "$e1")
+        assert not called[0]
+    run(_inner())
+
+
+def test_write_audit_never_raises():
+    async def _inner():
+        async def fake_post(*args, **kwargs):
+            raise ConnectionError("audit server down")
+
+        client = MagicMock()
+        client.post = fake_post
+        # Should not raise
+        await _write_audit(client, CONSOLE_URL, INTERNAL_TOKEN, "matrix.test", "sofiia", "NODA1", ROOM_ID, "$e1")
+    run(_inner())
+
+
+# ── Full loop: ingress + egress + audit ────────────────────────────────────────
+
+def test_loop_full_cycle_invoke_and_reply():
+    """One message → router invoked → send_text called with reply."""
+    async def _inner():
+        router_calls: List[Dict] = []
+        send_calls: List[Dict] = []
+        audit_calls: List[Dict] = []
 
         stop = asyncio.Event()
         loop = _make_loop()
 
-        sync_responses = [
-            _fake_sync_resp([MOCK_EVENT_1]),
-            _fake_sync_resp([]),     # empty on second poll
-        ]
         call_count = [0]
 
         async def fake_sync_poll(**kwargs):
-            idx = call_count[0]
             call_count[0] += 1
-            if idx >= len(sync_responses):
+            if call_count[0] > 1:
                 stop.set()
                 return {"next_batch": "end", "rooms": {}}
-            return sync_responses[idx]
+            return _fake_sync([MSG_EVENT])
+
+        def fake_extract(sync_resp, room_id):
+            events = sync_resp.get("rooms", {}).get("join", {}).get(room_id, {}).get("timeline", {}).get("events", [])
+            return [e for e in events if e.get("type") == "m.room.message" and e.get("sender") != BOT_USER]
+
+        async def fake_http_post(url, *, json=None, headers=None, timeout=None):
+            if "/infer" in url:
+                router_calls.append({"url": url, "json": json})
+                return _ok_response("Привіт! Я готова допомогти.")
+            elif "/audit/internal" in url:
+                audit_calls.append({"url": url, "json": json})
+                return _audit_response()
+            return _audit_response()
+
+        async def fake_send_text(room_id, text, txn_id):
+            send_calls.append({"room_id": room_id, "text": text, "txn_id": txn_id})
+            return {"event_id": "$reply_event"}
 
         with patch("app.ingress.MatrixClient") as MockClient:
-            mock_mc_instance = AsyncMock()
-            mock_mc_instance.__aenter__ = AsyncMock(return_value=mock_mc_instance)
-            mock_mc_instance.__aexit__ = AsyncMock(return_value=False)
-            mock_mc_instance.sync_poll = fake_sync_poll
-            mock_mc_instance.join_room = AsyncMock()
-            mock_mc_instance.mark_seen = MagicMock()
-            mock_mc_instance.is_duplicate = MagicMock(return_value=False)
+            mock_mc = AsyncMock()
+            mock_mc.__aenter__ = AsyncMock(return_value=mock_mc)
+            mock_mc.__aexit__ = AsyncMock(return_value=False)
+            mock_mc.sync_poll = fake_sync_poll
+            mock_mc.join_room = AsyncMock()
+            mock_mc.mark_seen = MagicMock()
+            mock_mc.extract_room_messages = fake_extract
+            mock_mc.send_text = fake_send_text
 
-            def fake_extract(sync_resp, room_id):
-                events = sync_resp.get("rooms", {}).get("join", {}).get(room_id, {}).get("timeline", {}).get("events", [])
-                return [e for e in events if e.get("type") == "m.room.message" and e.get("sender") != BOT_USER]
-
-            mock_mc_instance.extract_room_messages = fake_extract
-            MockClient.return_value = mock_mc_instance
+            # Patch MatrixClient.make_txn_id as static method
+            MockClient.return_value = mock_mc
+            MockClient.make_txn_id = lambda r, e: f"txn_{e}"
 
             with patch("app.ingress.httpx.AsyncClient") as MockHTTP:
                 mock_http = AsyncMock()
                 mock_http.__aenter__ = AsyncMock(return_value=mock_http)
                 mock_http.__aexit__ = AsyncMock(return_value=False)
-                mock_http.post = fake_post
+                mock_http.post = fake_http_post
                 MockHTTP.return_value = mock_http
 
                 await asyncio.wait_for(loop.run(stop), timeout=3.0)
 
-        # Gateway should have been invoked exactly once (for MOCK_EVENT_1)
-        assert len(received_calls) == 1
-        assert received_calls[0]["json"]["message"] == "Hello Sofiia!"
+        # Router invoked once
+        assert len(router_calls) == 1
+        assert "sofiia" in router_calls[0]["url"]
+        assert router_calls[0]["json"]["prompt"] == "Привіт Sofiia!"
+
+        # Reply sent once
+        assert len(send_calls) == 1
+        assert send_calls[0]["room_id"] == ROOM_ID
+        assert send_calls[0]["text"] == "Привіт! Я готова допомогти."
+
+        # Audit events: at least received + replied
+        audit_events = [a["json"]["event"] for a in audit_calls]
+        assert "matrix.message.received" in audit_events
+        assert "matrix.agent.replied" in audit_events
 
     run(_inner())
 
 
-def test_ingress_loop_deduplicates_same_event():
-    """Same event_id appearing twice should only invoke gateway once."""
+def test_loop_deduplication_no_double_invoke():
+    """Same event_id in two syncs → router called exactly once."""
     async def _inner():
-        invoke_count = [0]
-
-        async def fake_post(url, *, json=None, timeout=None):
-            invoke_count[0] += 1
-            resp = MagicMock()
-            resp.status_code = 200
-            resp.json.return_value = {"ok": True}
-            resp.raise_for_status = MagicMock()
-            return resp
-
-        stop = asyncio.Event()
-        loop = _make_loop()
-
-        # Same event in two consecutive syncs
-        sync_responses = [
-            _fake_sync_resp([MOCK_EVENT_1]),
-            _fake_sync_resp([MOCK_EVENT_1]),  # duplicate event_id
-        ]
-        call_count = [0]
+        router_calls = [0]
         seen = set()
 
+        stop = asyncio.Event()
+        loop = _make_loop()
+
+        call_count = [0]
+
         async def fake_sync_poll(**kwargs):
-            idx = call_count[0]
             call_count[0] += 1
-            if idx >= len(sync_responses):
+            if call_count[0] > 2:
                 stop.set()
                 return {"next_batch": "end", "rooms": {}}
-            return sync_responses[idx]
+            return _fake_sync([MSG_EVENT])
+
+        def fake_extract(sync_resp, room_id):
+            events = sync_resp.get("rooms", {}).get("join", {}).get(room_id, {}).get("timeline", {}).get("events", [])
+            return [e for e in events if e.get("type") == "m.room.message"
+                    and e.get("sender") != BOT_USER
+                    and e.get("event_id") not in seen]
+
+        def fake_mark_seen(eid):
+            seen.add(eid)
+
+        async def fake_http_post(url, *, json=None, headers=None, timeout=None):
+            if "/infer" in url:
+                router_calls[0] += 1
+                return _ok_response("response")
+            return _audit_response()
 
         with patch("app.ingress.MatrixClient") as MockClient:
-            mock_mc_instance = AsyncMock()
-            mock_mc_instance.__aenter__ = AsyncMock(return_value=mock_mc_instance)
-            mock_mc_instance.__aexit__ = AsyncMock(return_value=False)
-            mock_mc_instance.sync_poll = fake_sync_poll
-            mock_mc_instance.join_room = AsyncMock()
-
-            def fake_mark_seen(event_id):
-                seen.add(event_id)
-
-            def fake_is_dup(event_id):
-                return event_id in seen
-
-            mock_mc_instance.mark_seen = fake_mark_seen
-            mock_mc_instance.is_duplicate = fake_is_dup
-
-            def fake_extract(sync_resp, room_id):
-                events = sync_resp.get("rooms", {}).get("join", {}).get(room_id, {}).get("timeline", {}).get("events", [])
-                return [e for e in events if e.get("type") == "m.room.message"
-                        and e.get("sender") != BOT_USER
-                        and not fake_is_dup(e.get("event_id", ""))]
-
-            mock_mc_instance.extract_room_messages = fake_extract
-            MockClient.return_value = mock_mc_instance
+            mock_mc = AsyncMock()
+            mock_mc.__aenter__ = AsyncMock(return_value=mock_mc)
+            mock_mc.__aexit__ = AsyncMock(return_value=False)
+            mock_mc.sync_poll = fake_sync_poll
+            mock_mc.join_room = AsyncMock()
+            mock_mc.mark_seen = fake_mark_seen
+            mock_mc.extract_room_messages = fake_extract
+            mock_mc.send_text = AsyncMock(return_value={"event_id": "$r"})
+            MockClient.return_value = mock_mc
+            MockClient.make_txn_id = lambda r, e: f"txn_{e}"
 
             with patch("app.ingress.httpx.AsyncClient") as MockHTTP:
                 mock_http = AsyncMock()
                 mock_http.__aenter__ = AsyncMock(return_value=mock_http)
                 mock_http.__aexit__ = AsyncMock(return_value=False)
-                mock_http.post = fake_post
+                mock_http.post = fake_http_post
                 MockHTTP.return_value = mock_http
 
                 await asyncio.wait_for(loop.run(stop), timeout=3.0)
 
-        # Dedupe: only 1 invoke despite 2 sync responses with same event
-        assert invoke_count[0] == 1
+        assert router_calls[0] == 1
 
     run(_inner())
 
 
-def test_ingress_loop_calls_metric_callbacks():
-    """on_message_received and on_gateway_error callbacks should fire."""
+def test_loop_empty_reply_skips_send():
+    """Empty reply from router → send_text NOT called."""
     async def _inner():
-        received_events = []
-        error_events = []
+        send_called = [False]
+        stop = asyncio.Event()
+        loop = _make_loop()
+
+        call_count = [0]
+
+        async def fake_sync_poll(**kwargs):
+            call_count[0] += 1
+            if call_count[0] > 1:
+                stop.set()
+                return {"next_batch": "end", "rooms": {}}
+            return _fake_sync([MSG_EVENT])
+
+        def fake_extract(sync_resp, room_id):
+            events = sync_resp.get("rooms", {}).get("join", {}).get(room_id, {}).get("timeline", {}).get("events", [])
+            return [e for e in events if e.get("type") == "m.room.message" and e.get("sender") != BOT_USER]
+
+        async def fake_http_post(url, *, json=None, headers=None, timeout=None):
+            if "/infer" in url:
+                resp = MagicMock()
+                resp.status_code = 200
+                resp.json.return_value = {"response": ""}  # empty
+                resp.raise_for_status = MagicMock()
+                return resp
+            return _audit_response()
+
+        async def fake_send_text(room_id, text, txn_id):
+            send_called[0] = True
+            return {"event_id": "$r"}
+
+        with patch("app.ingress.MatrixClient") as MockClient:
+            mock_mc = AsyncMock()
+            mock_mc.__aenter__ = AsyncMock(return_value=mock_mc)
+            mock_mc.__aexit__ = AsyncMock(return_value=False)
+            mock_mc.sync_poll = fake_sync_poll
+            mock_mc.join_room = AsyncMock()
+            mock_mc.mark_seen = MagicMock()
+            mock_mc.extract_room_messages = fake_extract
+            mock_mc.send_text = fake_send_text
+            MockClient.return_value = mock_mc
+            MockClient.make_txn_id = lambda r, e: f"txn_{e}"
+
+            with patch("app.ingress.httpx.AsyncClient") as MockHTTP:
+                mock_http = AsyncMock()
+                mock_http.__aenter__ = AsyncMock(return_value=mock_http)
+                mock_http.__aexit__ = AsyncMock(return_value=False)
+                mock_http.post = fake_http_post
+                MockHTTP.return_value = mock_http
+
+                await asyncio.wait_for(loop.run(stop), timeout=3.0)
+
+        assert not send_called[0]
+
+    run(_inner())
+
+
+def test_loop_metric_callbacks_fire():
+    """on_message_received and on_message_replied should be called."""
+    async def _inner():
+        received = []
+        replied = []
 
         stop = asyncio.Event()
         loop = _make_loop(
-            on_message_received=lambda room, agent: received_events.append((room, agent)),
-            on_gateway_error=lambda etype: error_events.append(etype),
+            on_message_received=lambda r, a: received.append((r, a)),
+            on_message_replied=lambda r, a, s: replied.append((r, a, s)),
         )
 
         call_count = [0]
@@ -270,7 +408,16 @@ def test_ingress_loop_calls_metric_callbacks():
             if call_count[0] > 1:
                 stop.set()
                 return {"next_batch": "end", "rooms": {}}
-            return _fake_sync_resp([MOCK_EVENT_1])
+            return _fake_sync([MSG_EVENT])
+
+        def fake_extract(sync_resp, room_id):
+            events = sync_resp.get("rooms", {}).get("join", {}).get(room_id, {}).get("timeline", {}).get("events", [])
+            return [e for e in events if e.get("type") == "m.room.message" and e.get("sender") != BOT_USER]
+
+        async def fake_http_post(url, *, json=None, headers=None, timeout=None):
+            if "/infer" in url:
+                return _ok_response("test reply")
+            return _audit_response()
 
         with patch("app.ingress.MatrixClient") as MockClient:
             mock_mc = AsyncMock()
@@ -279,73 +426,23 @@ def test_ingress_loop_calls_metric_callbacks():
             mock_mc.sync_poll = fake_sync_poll
             mock_mc.join_room = AsyncMock()
             mock_mc.mark_seen = MagicMock()
-            mock_mc.is_duplicate = MagicMock(return_value=False)
-
-            def fake_extract(sync_resp, room_id):
-                events = sync_resp.get("rooms", {}).get("join", {}).get(room_id, {}).get("timeline", {}).get("events", [])
-                return [e for e in events if e.get("type") == "m.room.message" and e.get("sender") != BOT_USER]
-
             mock_mc.extract_room_messages = fake_extract
+            mock_mc.send_text = AsyncMock(return_value={"event_id": "$r"})
             MockClient.return_value = mock_mc
+            MockClient.make_txn_id = lambda r, e: f"txn_{e}"
 
             with patch("app.ingress.httpx.AsyncClient") as MockHTTP:
                 mock_http = AsyncMock()
                 mock_http.__aenter__ = AsyncMock(return_value=mock_http)
                 mock_http.__aexit__ = AsyncMock(return_value=False)
-
-                async def fake_post(url, *, json=None, timeout=None):
-                    resp = MagicMock()
-                    resp.status_code = 200
-                    resp.json.return_value = {"ok": True}
-                    resp.raise_for_status = MagicMock()
-                    return resp
-
-                mock_http.post = fake_post
+                mock_http.post = fake_http_post
                 MockHTTP.return_value = mock_http
 
                 await asyncio.wait_for(loop.run(stop), timeout=3.0)
 
-        assert len(received_events) == 1
-        assert received_events[0] == (ROOM_ID, "sofiia")
-
-    run(_inner())
-
-
-def test_ingress_loop_no_mappings_is_idle():
-    """Loop with 0 mappings should start and stop cleanly without invoking gateway."""
-    async def _inner():
-        empty_map = parse_room_map("", ALLOWED)
-        loop = MatrixIngressLoop(
-            matrix_homeserver_url=HS_URL,
-            matrix_access_token=TOKEN,
-            matrix_user_id=BOT_USER,
-            gateway_url=GW_URL,
-            node_id="NODA1",
-            room_map=empty_map,
-        )
-        stop = asyncio.Event()
-
-        with patch("app.ingress.MatrixClient") as MockClient:
-            mock_mc = AsyncMock()
-            mock_mc.__aenter__ = AsyncMock(return_value=mock_mc)
-            mock_mc.__aexit__ = AsyncMock(return_value=False)
-
-            async def fake_sync_poll(**kwargs):
-                stop.set()
-                return {"next_batch": "end", "rooms": {}}
-
-            mock_mc.sync_poll = fake_sync_poll
-            MockClient.return_value = mock_mc
-
-            with patch("app.ingress.httpx.AsyncClient") as MockHTTP:
-                mock_http = AsyncMock()
-                mock_http.__aenter__ = AsyncMock(return_value=mock_http)
-                mock_http.__aexit__ = AsyncMock(return_value=False)
-                MockHTTP.return_value = mock_http
-
-                await asyncio.wait_for(loop.run(stop), timeout=3.0)
-
-        # Should complete without error
-        assert True
+        assert len(received) == 1
+        assert received[0] == (ROOM_ID, "sofiia")
+        assert len(replied) == 1
+        assert replied[0][2] == "ok"
 
     run(_inner())