coding-bridge 2026.7.2.3__tar.gz → 2026.7.3.0__tar.gz

{coding_bridge-2026.7.2.3 → coding_bridge-2026.7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-bridge
-Version: 2026.7.2.3
+Version: 2026.7.3.0
 Summary: Node daemon for AceDataCloud Coding Bridge — run Claude Code on your own machine and drive it from the web.
 Project-URL: Homepage, https://github.com/AceDataCloud/CodingBridge
 Project-URL: Issues, https://github.com/AceDataCloud/CodingBridge/issues

coding_bridge-2026.7.3.0/coding_bridge/channels/__init__.py

@@ -0,0 +1,29 @@
+"""Messaging channels: run a coding-agent turn per inbound external message.
+
+Existing coding-bridge shape: browser ⇄ relay WSS ⇄ ``BridgeConnection`` node.
+Channels shape: external messenger (WeChat / Telegram / …) ⇄ ``ChannelAdapter``
+⇄ ``SessionDispatcher`` ⇄ existing ``Session`` + ``Provider``. The relay path is
+untouched; channels are an additive second entry-point built on the same
+``Provider`` layer.
+
+See ``plans/coding-bridge-channels/01-production-plan.md`` in AceDataCloud/Index
+for the P1..P11 roadmap this module implements.
+"""
+
+from .base import (
+    ChannelAdapter,
+    ChannelTarget,
+    IncomingMessage,
+    MessageHandler,
+    SendResult,
+)
+from .dispatcher import SessionDispatcher
+
+__all__ = [
+    "ChannelAdapter",
+    "ChannelTarget",
+    "IncomingMessage",
+    "MessageHandler",
+    "SendResult",
+    "SessionDispatcher",
+]

coding_bridge-2026.7.3.0/coding_bridge/channels/base.py

@@ -0,0 +1,107 @@
+"""Channel-adapter Protocol and value objects shared by every messenger.
+
+An adapter is the thin glue between one external messaging system (WeChat via
+Wisdom, later Telegram / Discord …) and the dispatcher. It never spawns provider
+processes, tracks sessions, or evaluates prompts — those live in
+``SessionDispatcher`` and reuse the existing ``Session`` / ``Provider`` machinery
+so the browser and WeChat paths share one coding-agent implementation.
+
+Design invariants:
+
+* ``instance_id`` is opaque to the dispatcher but MUST be stable per adapter
+  instance (per configured Wisdom endpoint, per Bot token, …) so multi-instance
+  deployments can namespace dedup keys, log fields, and outbox rows.
+* ``send()`` is expected to return a ``SendResult`` — never raise on a delivery
+  failure — because delivery is best-effort and the dispatcher records the
+  outcome for observability + retry decisions.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import Any, Protocol, runtime_checkable
+
+
+@dataclass(frozen=True)
+class ChannelTarget:
+    """Where a reply for an incoming message should be delivered.
+
+    ``conversation_id`` is the ID of the "room" — a WeChat private chat wxid, a
+    group room id, a Telegram chat_id, etc. ``reply_to_id`` is set only when the
+    external protocol supports a reply-to primitive worth carrying (WeChat
+    Wisdom's ``msg_id``, Telegram's ``reply_to_message_id``); adapters that lack
+    one leave it ``None``.
+    """
+
+    conversation_id: str
+    conversation_type: str = "private"
+    reply_to_id: str | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class IncomingMessage:
+    """A single external message routed to the dispatcher.
+
+    ``sender_id`` MUST be stable per remote identity (WeChat wxid, Telegram
+    user_id, …) — the dispatcher uses it for allowlists, rate limits, and per-
+    sender session keying.
+    """
+
+    sender_id: str
+    sender_name: str | None
+    target: ChannelTarget
+    text: str
+    msg_type: str
+    direction: str  # ``inbound`` / ``outbound`` (per Wisdom's schema)
+    upstream_id: str | None = None
+    received_at_ms: int | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class SendResult:
+    """Outcome of an adapter ``send()`` call. Non-raising by contract."""
+
+    ok: bool
+    upstream_id: str | None = None
+    error: str | None = None
+    latency_ms: int | None = None
+
+
+# ``handler(msg, adapter)`` — the dispatcher installs one before ``run()``.
+MessageHandler = Callable[["IncomingMessage", "ChannelAdapter"], Awaitable[None]]
+
+
+@runtime_checkable
+class ChannelAdapter(Protocol):
+    """One long-lived connection to an external messaging system.
+
+    Lifecycle:
+
+    1. Construct — parse settings, do NOT open sockets yet.
+    2. ``set_handler(h)`` — dispatcher registers the callback.
+    3. ``run()`` — subscribe loop; must call ``handler(msg, self)`` per inbound
+       message. Should reconnect internally on transient failures. Returns only
+       on ``aclose()`` or an unrecoverable auth failure.
+    4. ``send(target, text)`` — outbound reply.
+    5. ``aclose()`` — signal ``run()`` to stop; idempotent.
+
+    Adapters MUST NOT retain references to the dispatcher itself — only the
+    handler callback — so the dispatcher can outlive individual adapters (and
+    vice versa) without leaks.
+    """
+
+    name: str
+    instance_id: str
+
+    def set_handler(self, handler: MessageHandler) -> None: ...
+
+    async def run(self) -> None: ...
+
+    async def send(
+        self, target: ChannelTarget, text: str, *, reply_to: str | None = None
+    ) -> SendResult: ...
+
+    async def aclose(self) -> None: ...

coding_bridge-2026.7.3.0/coding_bridge/channels/dispatcher.py

@@ -0,0 +1,203 @@
+"""Route external messages to per-session provider turns and post replies back.
+
+The dispatcher is the channel-side counterpart of ``BridgeConnection`` — it owns
+the map from ``(instance_id, sender_id, conversation_id)`` to a live ``Session``,
+converts each session's event stream into a single text reply, and hands the
+reply to the originating adapter's ``send()``.
+
+Session lifecycle (v1 = one-shot per message):
+
+* Every inbound message spawns a fresh ``Session`` and immediately closes it
+  when the provider emits ``session.result`` or ``session.error``. Persisting
+  context across messages ("resume") is deferred so v1 stays simple and each
+  send/receive pair is auditable in isolation.
+
+* Concurrency guard: only one in-flight turn per session key. A second message
+  arriving before the current turn completes is deferred to the caller (the
+  adapter decides whether to buffer, drop, or warn) via a ``BusyError``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+import uuid
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from ..config import Settings
+from ..protocol import Event
+from ..providers.base import ProviderFactory
+from ..session import Session
+from .base import ChannelAdapter, ChannelTarget, IncomingMessage, SendResult
+
+logger = logging.getLogger("coding-bridge.channels")
+
+# ``(adapter_name, instance_id, sender_id, conversation_id)`` — the key namespace
+# the dispatcher uses to route replies. ``adapter_name`` guards against future
+# collisions when a user runs both a WeChat and a Telegram adapter at once.
+SessionKey = tuple[str, str, str, str]
+
+# Emitted after a session finishes; carries the concatenated reply text so the
+# adapter can post it. Never raises — the dispatcher swallows adapter errors and
+# logs them so a broken adapter can't kill sibling sessions.
+ReplySink = Callable[[ChannelAdapter, ChannelTarget, str], Awaitable[SendResult]]
+
+
+class BusyError(RuntimeError):
+    """Raised by ``handle_message`` when a session key already has an in-flight turn."""
+
+
+class _Turn:
+    """Accumulates text_delta / text / result events for one provider turn."""
+
+    def __init__(self) -> None:
+        self._parts: list[str] = []
+        self._done = asyncio.Event()
+        self._error: str | None = None
+
+    def on_event(self, payload: dict[str, Any]) -> None:
+        event = payload.get("event")
+        if event in (Event.SESSION_TEXT, Event.SESSION_TEXT_DELTA):
+            text = payload.get("text")
+            if isinstance(text, str) and text:
+                self._parts.append(text)
+        elif event == Event.SESSION_RESULT:
+            # Some providers emit their final text only in ``result.text`` and
+            # never stream a session.text — pick that up so we don't reply blank.
+            result_text = payload.get("text") or payload.get("result")
+            if isinstance(result_text, str) and result_text and not self._parts:
+                self._parts.append(result_text)
+            self._done.set()
+        elif event == Event.SESSION_ERROR:
+            err = payload.get("message") or payload.get("code") or "provider_error"
+            self._error = str(err)
+            self._done.set()
+        elif event == Event.SESSION_CLOSED:
+            self._done.set()
+
+    def text(self) -> str:
+        return "".join(self._parts).strip()
+
+    def error(self) -> str | None:
+        return self._error
+
+    async def wait(self, timeout: float | None) -> bool:
+        try:
+            await asyncio.wait_for(self._done.wait(), timeout=timeout)
+        except asyncio.TimeoutError:
+            return False
+        return True
+
+
+class SessionDispatcher:
+    """Fan external messages into ``Session`` turns and fan replies back out."""
+
+    def __init__(
+        self,
+        settings: Settings,
+        provider_factory: ProviderFactory,
+        *,
+        reply_sink: ReplySink | None = None,
+        turn_timeout: float = 300.0,
+        default_provider: str = "claude",
+    ) -> None:
+        self.settings = settings
+        self._factory = provider_factory
+        self._reply_sink = reply_sink or _default_reply_sink
+        self._turn_timeout = turn_timeout
+        self._default_provider = default_provider
+        self._inflight: dict[SessionKey, asyncio.Task[Any]] = {}
+        self._lock = asyncio.Lock()
+
+    def key_for(self, msg: IncomingMessage, adapter: ChannelAdapter) -> SessionKey:
+        return (adapter.name, adapter.instance_id, msg.sender_id, msg.target.conversation_id)
+
+    async def handle_message(self, msg: IncomingMessage, adapter: ChannelAdapter) -> None:
+        """Spawn one turn for ``msg``. Raises ``BusyError`` if a turn is in flight.
+
+        Non-raising for anything else — a provider crash or send failure is
+        logged and reported to the caller only via the returned coroutine
+        completing (there is no exception to re-raise on the adapter thread).
+        """
+        key = self.key_for(msg, adapter)
+        async with self._lock:
+            if key in self._inflight and not self._inflight[key].done():
+                raise BusyError(f"turn already running for {key!r}")
+            task = asyncio.create_task(self._run_turn(key, msg, adapter))
+            self._inflight[key] = task
+        # Fire-and-forget: the adapter loop must not block on this turn.
+
+    async def aclose(self) -> None:
+        async with self._lock:
+            tasks = [t for t in self._inflight.values() if not t.done()]
+            self._inflight.clear()
+        for t in tasks:
+            t.cancel()
+        for t in tasks:
+            with contextlib.suppress(BaseException):
+                await t
+
+    async def _run_turn(
+        self, key: SessionKey, msg: IncomingMessage, adapter: ChannelAdapter
+    ) -> None:
+        session_id = uuid.uuid4().hex
+        turn = _Turn()
+
+        async def emit(payload: dict[str, Any]) -> None:
+            turn.on_event(payload)
+
+        session = Session(
+            session_id=session_id,
+            provider_factory=self._factory,
+            emit=emit,
+            settings=self.settings,
+            cwd=self.settings.default_cwd,
+            model=self.settings.default_model,
+            permission_mode="default",
+            provider=self._default_provider,
+        )
+        try:
+            await session.start(msg.text)
+            ok = await turn.wait(self._turn_timeout)
+            reply = turn.text()
+            # Error takes precedence over any text already streamed — if the
+            # provider emits SESSION_RESULT and then SESSION_ERROR (buggy
+            # provider), we surface the error instead of silently returning the
+            # stale text.
+            if turn.error():
+                reply = f"(provider error: {turn.error()})"
+            elif not ok:
+                reply = reply or "(provider timed out; no reply)"
+            if not reply:
+                reply = "(no reply)"
+            try:
+                result = await self._reply_sink(adapter, msg.target, reply)
+            except Exception as exc:  # defensive: adapter send should not kill dispatcher
+                logger.exception("channel send failed: %s", exc)
+                return
+            if not result.ok:
+                logger.warning(
+                    "channel send returned failure: adapter=%s instance=%s error=%s",
+                    adapter.name,
+                    adapter.instance_id,
+                    result.error,
+                )
+        finally:
+            with contextlib.suppress(BaseException):
+                await session.close()
+            async with self._lock:
+                if self._inflight.get(key) is asyncio.current_task():
+                    self._inflight.pop(key, None)
+
+
+async def _default_reply_sink(
+    adapter: ChannelAdapter, target: ChannelTarget, text: str
+) -> SendResult:
+    """Fallback sink used when the caller didn't supply one — just calls send()."""
+
+    return await adapter.send(target, text)
+
+
+__all__ = ["SessionDispatcher", "BusyError", "ReplySink"]

{coding_bridge-2026.7.2.3 → coding_bridge-2026.7.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "coding-bridge"
-version = "2026.7.2.3"
+version = "2026.7.3.0"
 description = "Node daemon for AceDataCloud Coding Bridge — run Claude Code on your own machine and drive it from the web."
 readme = "README.md"
 requires-python = ">=3.10"

coding_bridge-2026.7.3.0/tests/test_channels_base.py

@@ -0,0 +1,91 @@
+"""P1: ChannelAdapter Protocol conformance + value-object smoke tests."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import FrozenInstanceError
+
+import pytest
+
+from coding_bridge.channels import (
+    ChannelAdapter,
+    ChannelTarget,
+    IncomingMessage,
+    SendResult,
+)
+
+
+class _FakeAdapter:
+    """Minimal ChannelAdapter — used only to verify runtime_checkable Protocol."""
+
+    name = "fake"
+    instance_id = "inst-1"
+
+    def __init__(self) -> None:
+        self.sent: list[tuple[ChannelTarget, str, str | None]] = []
+        self.closed = False
+
+    def set_handler(self, handler):  # noqa: ANN001 — test double
+        self.handler = handler
+
+    async def run(self) -> None:
+        return None
+
+    async def send(self, target, text, *, reply_to=None):  # noqa: ANN001
+        self.sent.append((target, text, reply_to))
+        return SendResult(ok=True, upstream_id="u1", latency_ms=1)
+
+    async def aclose(self) -> None:
+        self.closed = True
+
+
+def test_channel_adapter_protocol_conformance() -> None:
+    """A minimal concrete adapter satisfies the runtime-checkable Protocol."""
+
+    adapter = _FakeAdapter()
+    assert isinstance(adapter, ChannelAdapter)
+
+
+def test_channel_target_is_frozen_and_defaults_private() -> None:
+    target = ChannelTarget(conversation_id="wxid_abc")
+    assert target.conversation_type == "private"
+    assert target.reply_to_id is None
+    assert target.extra == {}
+    with pytest.raises(FrozenInstanceError):
+        target.conversation_id = "other"  # type: ignore[misc]
+
+
+def test_incoming_message_is_frozen() -> None:
+    msg = IncomingMessage(
+        sender_id="wxid_sender",
+        sender_name="Alice",
+        target=ChannelTarget(conversation_id="wxid_room"),
+        text="/ask hi",
+        msg_type="text",
+        direction="inbound",
+        upstream_id="msg-1",
+    )
+    assert msg.sender_id == "wxid_sender"
+    assert msg.direction == "inbound"
+    with pytest.raises(FrozenInstanceError):
+        msg.text = "hijacked"  # type: ignore[misc]
+
+
+def test_send_result_defaults() -> None:
+    r = SendResult(ok=False, error="429 too many")
+    assert r.ok is False
+    assert r.upstream_id is None
+    assert r.error == "429 too many"
+    assert r.latency_ms is None
+
+
+def test_send_returns_send_result() -> None:
+    """Contract: send() returns a SendResult, never raises for delivery failure."""
+
+    async def _go() -> None:
+        adapter = _FakeAdapter()
+        r = await adapter.send(ChannelTarget(conversation_id="c1"), "hi")
+        assert isinstance(r, SendResult)
+        assert r.ok is True
+
+    asyncio.run(_go())

coding_bridge-2026.7.3.0/tests/test_channels_dispatcher.py

@@ -0,0 +1,242 @@
+"""P1: SessionDispatcher — fan external messages into provider turns."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import pytest
+
+from coding_bridge.channels import (
+    ChannelTarget,
+    IncomingMessage,
+    SendResult,
+    SessionDispatcher,
+)
+from coding_bridge.channels.dispatcher import BusyError
+from coding_bridge.config import Settings
+from coding_bridge.protocol import Event, event_payload
+
+# 5 s ceiling gives slow CI runners headroom while keeping local test runs fast.
+_POLL_ITERATIONS = 1000
+_POLL_INTERVAL_S = 0.005
+
+
+async def _wait_until(pred, iterations: int = _POLL_ITERATIONS) -> None:
+    for _ in range(iterations):
+        if pred():
+            return
+        await asyncio.sleep(_POLL_INTERVAL_S)
+
+
+class _StubProvider:
+    """A provider whose ``start()`` emits scripted events and completes."""
+
+    name = "stub"
+
+    def __init__(self, session_id: str, emit, _ask, script: list[dict[str, Any]] | None = None):
+        self._session_id = session_id
+        self._emit = emit
+        self._script = (
+            script
+            if script is not None
+            else [
+                event_payload(Event.SESSION_TEXT, session_id, text="hello, "),
+                event_payload(Event.SESSION_TEXT, session_id, text="world"),
+                event_payload(Event.SESSION_RESULT, session_id, text="hello, world"),
+            ]
+        )
+
+    async def start(self, _prompt, **_kw):
+        for payload in self._script:
+            await self._emit(payload)
+
+    async def send(self, _prompt, **_kw):
+        return
+
+    async def edit(self, *_a, **_kw):
+        return
+
+    async def interrupt(self):
+        return
+
+    async def aclose(self):
+        return
+
+
+def _factory(script=None):
+    def _make(_provider_name, session_id, emit, ask):
+        return _StubProvider(session_id, emit, ask, script=script)
+
+    return _make
+
+
+class _RecordingAdapter:
+    name = "wechat"
+    instance_id = "beijing-cvm"
+
+    def __init__(self) -> None:
+        self.replies: list[tuple[str, str]] = []
+        self._handler = None
+
+    def set_handler(self, h):
+        self._handler = h
+
+    async def run(self):
+        return
+
+    async def send(self, target: ChannelTarget, text: str, *, reply_to=None) -> SendResult:
+        self.replies.append((target.conversation_id, text))
+        return SendResult(ok=True, upstream_id="upstream-1", latency_ms=42)
+
+    async def aclose(self):
+        return
+
+
+def _msg(sender: str = "wxid_a", conv: str = "wxid_a", text: str = "/ask hi") -> IncomingMessage:
+    return IncomingMessage(
+        sender_id=sender,
+        sender_name=None,
+        target=ChannelTarget(conversation_id=conv),
+        text=text,
+        msg_type="text",
+        direction="inbound",
+    )
+
+
+@pytest.mark.asyncio
+async def test_handle_message_concatenates_text_and_sends_reply(tmp_path):
+    settings = Settings(config_dir=tmp_path)
+    dispatcher = SessionDispatcher(settings, provider_factory=_factory(), default_provider="stub")
+    adapter = _RecordingAdapter()
+
+    await dispatcher.handle_message(_msg(text="/ask ping"), adapter)
+    await _wait_until(lambda: bool(adapter.replies))
+
+    assert adapter.replies == [("wxid_a", "hello, world")]
+    await dispatcher.aclose()
+
+
+@pytest.mark.asyncio
+async def test_busy_error_when_second_message_for_same_key_arrives(tmp_path):
+    """A second message for the same (sender, conversation) while a turn is in flight raises."""
+
+    barrier = asyncio.Event()
+
+    class _SlowProvider(_StubProvider):
+        async def start(self, _prompt, **_kw):
+            await barrier.wait()
+            await self._emit(event_payload(Event.SESSION_RESULT, self._session_id, text="ok"))
+
+    def _slow_factory(_name, session_id, emit, ask):
+        return _SlowProvider(session_id, emit, ask)
+
+    settings = Settings(config_dir=tmp_path)
+    dispatcher = SessionDispatcher(
+        settings, provider_factory=_slow_factory, default_provider="stub"
+    )
+    adapter = _RecordingAdapter()
+
+    await dispatcher.handle_message(_msg(), adapter)
+    with pytest.raises(BusyError):
+        await dispatcher.handle_message(_msg(), adapter)
+    barrier.set()
+    await _wait_until(lambda: bool(adapter.replies))
+    assert adapter.replies == [("wxid_a", "ok")]
+    await dispatcher.aclose()
+
+
+@pytest.mark.asyncio
+async def test_different_conversations_run_concurrently(tmp_path):
+    """Two messages from different conversations get independent turns."""
+
+    settings = Settings(config_dir=tmp_path)
+    dispatcher = SessionDispatcher(settings, provider_factory=_factory(), default_provider="stub")
+    adapter = _RecordingAdapter()
+
+    await dispatcher.handle_message(_msg(sender="a", conv="a", text="/ask 1"), adapter)
+    await dispatcher.handle_message(_msg(sender="b", conv="b", text="/ask 2"), adapter)
+    await _wait_until(lambda: len(adapter.replies) >= 2)
+
+    convs = sorted(c for c, _ in adapter.replies)
+    assert convs == ["a", "b"]
+    await dispatcher.aclose()
+
+
+@pytest.mark.asyncio
+async def test_reply_sink_override_receives_final_text(tmp_path):
+    """A caller-supplied reply_sink is used in preference to adapter.send()."""
+
+    settings = Settings(config_dir=tmp_path)
+    captured: list[tuple[str, str]] = []
+
+    async def _sink(adapter, target, text):
+        captured.append((adapter.name, text))
+        return SendResult(ok=True)
+
+    dispatcher = SessionDispatcher(
+        settings,
+        provider_factory=_factory(),
+        reply_sink=_sink,
+        default_provider="stub",
+    )
+    adapter = _RecordingAdapter()
+    await dispatcher.handle_message(_msg(text="/ask hi"), adapter)
+    await _wait_until(lambda: bool(captured))
+
+    assert captured == [("wechat", "hello, world")]
+    assert adapter.replies == []  # sink bypassed .send()
+    await dispatcher.aclose()
+
+
+@pytest.mark.asyncio
+async def test_falls_back_to_no_reply_when_provider_emits_nothing(tmp_path):
+    """Provider that never emits any event → dispatcher timeout path fires."""
+
+    empty_script: list[dict[str, Any]] = []
+
+    async def _sink(_adapter, _target, text):
+        _sink.captured = text  # type: ignore[attr-defined]
+        return SendResult(ok=True)
+
+    _sink.captured = None  # type: ignore[attr-defined]
+
+    settings = Settings(config_dir=tmp_path)
+    dispatcher = SessionDispatcher(
+        settings,
+        provider_factory=_factory(script=empty_script),
+        reply_sink=_sink,
+        turn_timeout=0.1,
+        default_provider="stub",
+    )
+    adapter = _RecordingAdapter()
+
+    await dispatcher.handle_message(_msg(), adapter)
+    await _wait_until(lambda: _sink.captured is not None)  # type: ignore[attr-defined]
+
+    assert "timed out" in (_sink.captured or "")  # type: ignore[attr-defined]
+    await dispatcher.aclose()
+
+
+@pytest.mark.asyncio
+async def test_provider_error_takes_precedence_over_result_text(tmp_path):
+    """A buggy provider emitting SESSION_RESULT then SESSION_ERROR must surface the error."""
+
+    def _factory_err(_name, session_id, emit, _ask):
+        async def _start(_prompt, **_kw):
+            await emit(event_payload(Event.SESSION_RESULT, session_id, text="stale"))
+            await emit(event_payload(Event.SESSION_ERROR, session_id, message="boom"))
+
+        prov = _StubProvider(session_id, emit, _ask, script=[])
+        prov.start = _start  # type: ignore[method-assign]
+        return prov
+
+    settings = Settings(config_dir=tmp_path)
+    dispatcher = SessionDispatcher(settings, provider_factory=_factory_err, default_provider="stub")
+    adapter = _RecordingAdapter()
+
+    await dispatcher.handle_message(_msg(), adapter)
+    await _wait_until(lambda: bool(adapter.replies))
+
+    assert adapter.replies == [("wxid_a", "(provider error: boom)")]
+    await dispatcher.aclose()