ForcePilot/backend/package/yuxi/channels/adapters/whatsapp/adapter.py

from __future__ import annotations

import asyncio
import os
import tempfile
import time
from collections.abc import Awaitable, Callable
from typing import Any

import aiohttp

from yuxi.channels.base import BaseChannelAdapter
from yuxi.channels.capabilities import ChannelCapabilities, TTSVoiceCapabilities, TTSCapabilities
from yuxi.channels.exceptions import ChannelNotConnectedError
from yuxi.channels.meta import ChannelMeta as DisplayMeta
from yuxi.channels.models import (
    ChannelMessage,
    ChannelResponse,
    ChannelStatus,
    ChannelType,
    DeliveryResult,
    HealthStatus,
)
from yuxi.channels.registry import register_builtin_adapter
from yuxi.utils.datetime_utils import utc_now_naive
from yuxi.utils.logging_config import logger

from .bridge import BaileysBridge
from .channel_meta import ChannelMeta
from .connection_controller import ConnectionController, ConnectionState
from .credential_queue import CredentialQueue
from .debounce import MessageDebouncer
from .dedupe import ButtonDeduplicator, MessageDeduplicator
from .directory import PerGroupConfig
from .directory_peers import ContactDirectory
from .echo_filter import EchoFilter
from .inbound_cache import InboundMessageCache
from .error_policy import ErrorPolicyConfig
from .format import format_outbound as _format_outbound
from .format import normalize_inbound as _normalize_inbound
from .heartbeat import HeartbeatManager
from .inbound_pipeline import InboundPipeline, PipelineAction, PipelineResult
from .markdown import markdown_to_whatsapp, text_sanitizer
from .media import _MEDIA_SUFFIX_MAP, cleanup_temp_file
from .media import download_media as _download_media
from .monitor import WhatsAppMonitor
from .pairing import PairingManager
from .per_dm_config import PerDmConfig
from .reactions.ack_reaction import AckReactionManager
from .reactions.reaction_level import ReactionLevelController
from .security import DmPolicy, WhatsAppSecurityPolicy
from .send import chunk_message
from .sent_message_cache import SentMessageCache
from .session import jid_to_thread_key, normalize_phone, resolve_session_scope
from .stream.lane_delivery import LaneDelivery
from .vision.sticker_vision import StickerVision
from .watchdog import Watchdog


@register_builtin_adapter
class WhatsAppAdapter(BaseChannelAdapter):
    channel_id = "whatsapp"
    channel_type = ChannelType.WHATSAPP
    meta = DisplayMeta(
        id="whatsapp",
        label="WhatsApp",
        selection_label="WhatsApp",
        docs_path="docs/channels/whatsapp",
        docs_label="WhatsApp 文档",
        blurb="WhatsApp Bridge 适配器，通过 Baileys 协议连接 WhatsApp",
        order=9,
        aliases=["wa"],
        system_image="whatsapp",
        markdown_capable=True,
        exposure="public",
    )
    channel_meta = ChannelMeta()

    text_chunk_limit = 4000
    supports_markdown = True
    supports_streaming = True
    streaming_modes = ["off", "typing_indicator"]
    max_media_size_mb = 100

    capabilities = ChannelCapabilities(
        chat_types=["direct", "group"],
        polls=True,
        reactions=True,
        unsend=True,
        reply=True,
        media=True,
        supports_markdown=True,
        supports_streaming=True,
        streaming_modes=["off", "typing_indicator"],
        text_chunk_limit=4000,
        max_media_size_mb=100,
        block_streaming=True,
        tts=TTSCapabilities(
            voice=TTSVoiceCapabilities(
                synthesis_target="voice-note",
                transcodes_audio=True,
                enabled=False,
            )
        ),
    )

    def __init__(self, config: dict[str, Any] | None = None):
        super().__init__(config)
        cfg = config or {}
        self._status = ChannelStatus.DISCONNECTED
        self._bridge = BaileysBridge(cfg)
        self._monitor = WhatsAppMonitor(cfg, self._bridge)
        self._connection_ctrl = ConnectionController()
        self._heartbeat = HeartbeatManager(self._bridge)
        self._watchdog = Watchdog(timeout_seconds=cfg.get("watchdogTimeout", 30.0))
        self._security = WhatsAppSecurityPolicy(cfg)
        self._pairing = PairingManager()
        self._reaction_level = ReactionLevelController(cfg)
        self._ack_reaction = AckReactionManager(cfg)
        self._per_group_config = PerGroupConfig.from_config(cfg)
        self._per_dm_config = PerDmConfig.from_config(cfg)
        self._error_policy = ErrorPolicyConfig.from_config(cfg)
        self._block_streaming = cfg.get("blockStreaming", False)
        self._chunk_mode = cfg.get("chunkMode", "length")
        self._send_read_receipts = cfg.get("sendReadReceipts", False)
        self._reply_to_mode = cfg.get("replyToMode", "first")
        self._lane_delivery = LaneDelivery(cfg)
        self._sticker_vision = StickerVision(cfg)
        self._self_chat_mode = cfg.get("selfChatMode", False)
        self._default_to = cfg.get("defaultTo")
        self._contact_directory = ContactDirectory.from_config(cfg)
        self._401_retry_pending = False
        self._sent_message_cache = SentMessageCache(
            max_size=500,
            ttl_seconds=cfg.get("sentMessageCacheTtl", 3600),
        )
        self._inbound_cache = InboundMessageCache(
            max_size=500,
            ttl_seconds=600,
        )
        self._deduplicator = MessageDeduplicator(ttl_seconds=cfg.get("dedupeTtl", 300))
        self._button_deduplicator = ButtonDeduplicator(ttl_seconds=cfg.get("buttonDedupeTtl", 5.0))
        self._echo_filter = EchoFilter(ttl_seconds=cfg.get("echoTtl", 10.0))
        self._debouncer = MessageDebouncer(
            window_seconds=cfg.get("debounceWindow", 2.0),
            max_calls=cfg.get("debounceMaxCalls", 3),
        )
        self._creds_queue: CredentialQueue | None = None
        self._inbound_pipeline = self._build_inbound_pipeline()
        self._self_jid: str | None = None
        self._on_connection_change: Callable[[dict[str, Any]], Awaitable[None]] | None = None
        self._recent_messages: dict[str, dict[str, Any]] = {}
        self._last_inbound_at: float | None = None
        self._last_message_at: float | None = None

    async def connect(self) -> None:
        if self._status in (ChannelStatus.CONNECTED, ChannelStatus.CONNECTING):
            return

        self._status = ChannelStatus.CONNECTING
        self._connection_ctrl.transition(ConnectionState.CONNECTING)
        logger.info(f"[WhatsApp] Starting channel '{self.config.get('name', self.channel_id)}'")

        try:
            await self._bridge.start()
        except Exception as e:
            self._status = ChannelStatus.ERROR
            self._connection_ctrl.transition(ConnectionState.DISCONNECTED)
            logger.error(f"[WhatsApp] Bridge start failed: {e}")
            raise ChannelNotConnectedError() from e

        health = await self._bridge.health_check()
        if health.status == "healthy":
            self._self_jid = health.metadata.get("jid", "")
            logger.info(f"[WhatsApp] Connected as {self._self_jid}")
            self._connection_ctrl.transition(ConnectionState.ACTIVE)

            self._setup_monitor_handler()
            self._heartbeat.on_unhealthy(self._on_bridge_unhealthy)
            self._watchdog.on_timeout(self._on_watchdog_timeout)
            await self._monitor.start()
            await self._heartbeat.start()
            await self._watchdog.start()

            self._status = ChannelStatus.CONNECTED
            return

        self._status = ChannelStatus.CONNECTING
        self._connection_ctrl.transition(ConnectionState.QR_PENDING)
        logger.info("[WhatsApp] Waiting for QR login (call pre_connect first)")

    async def disconnect(self) -> None:
        if self._status == ChannelStatus.DISCONNECTED:
            return

        logger.info(f"[WhatsApp] Stopping channel '{self.config.get('name', self.channel_id)}'")

        await self._watchdog.stop()
        await self._heartbeat.stop()
        await self._monitor.stop()
        await self._bridge.stop()

        self._status = ChannelStatus.DISCONNECTED
        self._connection_ctrl.transition(ConnectionState.DISCONNECTED)
        self._self_jid = None

    async def pre_connect(self, force: bool = False) -> dict:
        if not force:
            health = await self._bridge.health_check()
            if health.status == "healthy":
                self._self_jid = health.metadata.get("jid", "")
                self._connection_ctrl.transition(ConnectionState.ACTIVE)
                return {"status": "logged_in", "jid": self._self_jid}

        qr_result = await self._bridge.get_qr()
        if qr_data := qr_result.get("qr"):
            self._connection_ctrl.transition(ConnectionState.QR_PENDING)
            return {"status": "pending_scan", "qr_base64": qr_data, "qr_type": "png_base64"}
        return {"status": "error", "error": "QR generation failed"}

    async def send(self, response: ChannelResponse, silent: bool = False) -> DeliveryResult:
        jid = response.identity.channel_chat_id
        if not jid and self._default_to:
            jid = self._default_to
        reply_to = response.reply_to_message_id

        if self._reply_to_mode == "off":
            reply_to = None

        if self._debouncer.should_throttle(jid):
            remaining = self._debouncer.window_remaining(jid)
            logger.warning(f"[WhatsApp] Throttled message to {jid} (retry in {remaining:.1f}s)")
            return DeliveryResult(
                success=False,
                error=f"Rate limited, retry in {remaining:.1f}s",
            )

        payload = _format_outbound(response)
        content = payload.get("content", response.content)
        content = text_sanitizer(content)

        if self.supports_markdown and getattr(response, "content_format", "") == "markdown":
            try:
                content = markdown_to_whatsapp(content)
            except Exception as e:
                logger.warning(f"[WhatsApp] Markdown parse failed, using plain text: {e}")

        prefix = self.config.get("messagePrefix", "")
        if prefix:
            content = f"{prefix} {content}"

        self._echo_filter.record_outbound(jid, content)
        self._debouncer.record_send(jid)
        self._last_message_at = time.monotonic()

        if len(content) > self.text_chunk_limit and self._reply_to_mode != "batched":
            chunks = chunk_message(content, self.text_chunk_limit, mode=self._chunk_mode)
            results = []
            for chunk in chunks:
                use_reply = reply_to if self._reply_to_mode == "all" else (reply_to if len(results) == 0 else None)
                result = await self._bridge.send_message(
                    jid=jid,
                    content=chunk,
                    reply_to=use_reply,
                    silent=silent,
                )
                results.append(result)
            return results[0] if results else DeliveryResult(success=False, error="No chunks")

        if self._reply_to_mode == "batched" and len(content) > self.text_chunk_limit:
            content = content[: self.text_chunk_limit - 3] + "..."

        return await self._send_with_retry(jid, content, reply_to, silent)

    async def send_media(self, chat_id: str, media_type: str, data: Any) -> DeliveryResult:
        suffix = _MEDIA_SUFFIX_MAP.get(media_type, "")
        if isinstance(data, bytes):
            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as f:
                f.write(data)
                tmp_path = f.name
        elif isinstance(data, str) and os.path.exists(data):
            tmp_path = data
        else:
            return DeliveryResult(success=False, error=f"Unsupported media data type: {type(data)}")

        try:
            return await self._bridge.send_media(
                jid=chat_id,
                media_type=media_type,
                media_path=tmp_path,
            )
        finally:
            if isinstance(data, bytes) and os.path.exists(tmp_path):
                cleanup_temp_file(tmp_path)

    async def send_reaction(self, chat_id: str, msg_id: str, emoji: str) -> DeliveryResult:
        if not emoji:
            return await self._bridge.send_reaction(
                jid=chat_id,
                message_id=msg_id,
                emoji="",
            )
        if not self._reaction_level.can_send_reaction():
            return DeliveryResult(success=False, error="Reactions disabled by reactionLevel config")
        return await self._bridge.send_reaction(
            jid=chat_id,
            message_id=msg_id,
            emoji=emoji,
        )

    async def remove_reaction(self, chat_id: str, msg_id: str) -> DeliveryResult:
        return await self.send_reaction(chat_id, msg_id, "")

    async def send_reaction_from_action(self, action: dict[str, Any]) -> DeliveryResult:
        chat_jid = action.get("chatJid") or action.get("to") or action.get("chat_id", "")
        msg_id = action.get("messageId") or action.get("msg_id", "")
        emoji = action.get("emoji", "")
        remove = action.get("remove", False)
        participant = action.get("participant", "")

        if participant and "@g.us" not in chat_jid:
            chat_jid = participant

        if remove or not emoji:
            return await self.send_reaction(chat_jid, msg_id, "")
        return await self.send_reaction(chat_jid, msg_id, emoji)

    async def download_media(self, file_id: str) -> bytes:
        raw = self._recent_messages.get(file_id)
        if not raw:
            raise ValueError(f"Message context not found for file_id: {file_id}")

        remote_jid = raw.get("key", {}).get("remoteJid", "")
        message = raw.get("message", {})
        return await _download_media(self._bridge, remote_jid, file_id, message)

    async def send_stream_chunk(self, chat_id: str, msg_id: str, chunk: str, finished: bool) -> DeliveryResult:
        if finished:
            content = text_sanitizer(chunk)
            if self.supports_markdown:
                content = markdown_to_whatsapp(content)

            if self._lane_delivery.reasoning_enabled:
                lane_chunks = self._lane_delivery.split_lane_aware(content)
                messages = self._lane_delivery.format_for_whatsapp(lane_chunks)
                results = []
                for msg in messages:
                    result = await self._bridge.send_message(jid=chat_id, content=msg)
                    results.append(result)
                return results[0] if results else DeliveryResult(success=False, error="No messages")

            return await self._bridge.send_message(
                jid=chat_id,
                content=content,
            )
        return await self._bridge.send_presence(
            jid=chat_id,
            presence="composing",
        )

    async def edit_message(self, chat_id: str, msg_id: str, content: str) -> DeliveryResult:
        return DeliveryResult(success=False, error="WhatsApp does not support editing messages")

    async def delete_message(self, chat_id: str, msg_id: str) -> DeliveryResult:
        return await self._bridge.delete_message(
            jid=chat_id,
            message_id=msg_id,
        )

    async def send_poll(self, chat_id: str, name: str, options: list[str], selectable_count: int = 1) -> DeliveryResult:
        if len(options) < 2:
            return DeliveryResult(success=False, error="Poll requires at least 2 options")
        if len(options) > 12:
            return DeliveryResult(success=False, error=f"Poll supports max 12 options, got {len(options)}")
        return await self._bridge.create_poll(
            jid=chat_id,
            name=name,
            options=options,
            selectable_count=selectable_count,
        )

    async def send_location(
        self,
        chat_id: str,
        latitude: float,
        longitude: float,
        name: str = "",
        address: str = "",
    ) -> DeliveryResult:
        return await self._bridge.send_location(
            jid=chat_id,
            latitude=latitude,
            longitude=longitude,
            name=name,
            address=address,
        )

    async def send_contact(
        self,
        chat_id: str,
        contacts: list[dict[str, str]],
    ) -> DeliveryResult:
        return await self._bridge.send_contact(
            jid=chat_id,
            contacts=contacts,
        )

    async def send_sticker(
        self,
        chat_id: str,
        sticker_path: str,
        reply_to: str | None = None,
    ) -> DeliveryResult:
        return await self._bridge.send_sticker(
            jid=chat_id,
            sticker_path=sticker_path,
            reply_to=reply_to,
        )

    async def send_buttons(
        self,
        chat_id: str,
        text: str,
        buttons: list[dict[str, str]],
        title: str = "",
        footer: str = "",
    ) -> DeliveryResult:
        return await self._bridge.send_buttons(
            jid=chat_id,
            text=text,
            buttons=buttons,
            title=title,
            footer=footer,
        )

    async def send_list_message(
        self,
        chat_id: str,
        text: str,
        sections: list[dict[str, Any]],
        title: str = "",
        footer: str = "",
        button_text: str = "Select",
    ) -> DeliveryResult:
        return await self._bridge.send_list_message(
            jid=chat_id,
            text=text,
            sections=sections,
            title=title,
            footer=footer,
            button_text=button_text,
        )

    def normalize_inbound(self, raw: dict[str, Any]) -> ChannelMessage:
        return _normalize_inbound(raw, self.channel_id)

    def format_outbound(self, response: ChannelResponse) -> Any:
        return _format_outbound(response)

    async def health_check(self) -> HealthStatus:
        bridge_health = await self._bridge.health_check()
        if self._status != ChannelStatus.CONNECTED:
            return HealthStatus(
                status="degraded",
                metadata={
                    "adapter_status": self._status.value,
                    "connection_state": self._connection_ctrl.state.value,
                    "bridge": bridge_health.metadata,
                },
            )
        return HealthStatus(
            status=bridge_health.status,
            latency_ms=bridge_health.latency_ms,
            last_error=bridge_health.last_error,
            last_connected_at=utc_now_naive() if bridge_health.status == "healthy" else None,
            metadata={
                "jid": self._self_jid or "",
                "adapter_status": self._status.value,
                "connection_state": self._connection_ctrl.state.value,
                "watchdog_alive": self._watchdog.is_alive(),
                "last_inbound_at": self._last_inbound_at,
                "last_message_at": self._last_message_at,
                **bridge_health.metadata,
            },
        )

    def on_connection_change(self, handler: Callable[[dict[str, Any]], Awaitable[None]]) -> None:
        self._on_connection_change = handler

    async def _handle_sse_event(self, raw_payload: dict[str, Any]) -> None:
        self._watchdog.feed()
        event_type = raw_payload.get("type", "")

        if event_type == "connection":
            status = raw_payload.get("status", "")
            reason = raw_payload.get("reason", "")

            if status == "close" and reason in ("logged_out_401", "logged_out"):
                logger.warning("[WhatsApp] Bridge reported logged out (401)")
                if not self._401_retry_pending:
                    self._401_retry_pending = True
                    logger.info("[WhatsApp] 401 detected, checking if transient (wait 5s)...")
                    await asyncio.sleep(5.0)
                    health = await self._bridge.health_check()
                    if health.status == "healthy":
                        self._401_retry_pending = False
                        self._connection_ctrl.transition(ConnectionState.ACTIVE)
                        self._self_jid = health.metadata.get("jid", self._self_jid)
                        logger.info("[WhatsApp] 401 was transient, connection recovered")
                        return
                    logger.warning("[WhatsApp] 401 confirmed as permanent, cleaning up")
                    self._401_retry_pending = False

                self._connection_ctrl.transition(ConnectionState.LOGGED_OUT)
                from .logout_security import perform_logout_cleanup
                from .auth_resolve import resolve_auth_dir

                auth_dir = resolve_auth_dir(self.channel_id, self.config)
                perform_logout_cleanup(auth_dir)

                if self._on_connection_change:
                    await self._on_connection_change(
                        {"status": "logged_out", "reason": reason, "code": raw_payload.get("statusCode")}
                    )
                return

            self._connection_ctrl.transition(
                ConnectionState.ACTIVE if raw_payload.get("status") == "open" else ConnectionState.DISCONNECTED
            )
            if self._on_connection_change:
                await self._on_connection_change(raw_payload)
            if self._connection_ctrl.state == ConnectionState.ACTIVE:
                logger.info("[WhatsApp] Connection opened")
                if self._status != ChannelStatus.CONNECTED:
                    health = await self._bridge.health_check()
                    self._self_jid = health.metadata.get("jid", self._self_jid)
                    self._status = ChannelStatus.CONNECTED
            return

        if event_type == "qr":
            self._connection_ctrl.transition(ConnectionState.QR_PENDING)
            logger.info("[WhatsApp] QR code event received")
            return

        if self._message_handler is None:
            return

        result = await self._inbound_pipeline.process(raw_payload)
        if result.action != PipelineAction.ACCEPT:
            self._echo_filter.clear()
            return

        self._last_inbound_at = time.monotonic()

        is_from_me = raw_payload.get("key", {}).get("fromMe", False)

        if is_from_me and not self._self_chat_mode:
            return

        msg_id = raw_payload.get("key", {}).get("id", "")

        if is_from_me and self._self_chat_mode:
            modified = raw_payload.copy()
            modified["key"] = {**raw_payload.get("key", {}), "fromMe": False}
            channel_msg = self.normalize_inbound(modified)
            channel_msg.metadata["from_me"] = True
        else:
            channel_msg = self.normalize_inbound(raw_payload)

        chat_id = channel_msg.identity.channel_chat_id
        is_group = "@g.us" in chat_id

        if msg_id and channel_msg.attachments:
            self._recent_messages[msg_id] = raw_payload
            if len(self._recent_messages) > 200:
                oldest = next(iter(self._recent_messages))
                del self._recent_messages[oldest]

        if not is_from_me and msg_id:
            msg_content = raw_payload.get("message", {})
            text = (
                msg_content.get("conversation", "")
                or (msg_content.get("extendedTextMessage") or {}).get("text", "")
                or (msg_content.get("imageMessage") or {}).get("caption", "")
                or (msg_content.get("videoMessage") or {}).get("caption", "")
                or (msg_content.get("documentMessage") or {}).get("caption", "")
            )
            self._inbound_cache.put(msg_id, chat_id, text)

        if not is_from_me and self._ack_reaction.can_ack(chat_id, is_group):
            asyncio.ensure_future(self._send_ack_reaction(chat_id, msg_id))

        if not is_from_me and self._send_read_receipts and msg_id:
            asyncio.ensure_future(self._send_read_receipt(chat_id, msg_id))

        if self._sticker_vision.enabled and channel_msg.attachments:
            asyncio.ensure_future(self._enrich_with_vision(channel_msg, raw_payload))

        await self._message_handler(channel_msg)

    async def _send_ack_reaction(self, chat_id: str, msg_id: str) -> None:
        if not msg_id:
            return
        try:
            await self._bridge.send_reaction(
                jid=chat_id,
                message_id=msg_id,
                emoji=self._ack_reaction.emoji,
            )
            self._ack_reaction.record_ack(chat_id)
        except Exception:
            logger.debug(f"[WhatsApp] ACK reaction failed for {msg_id}", exc_info=True)

    async def _send_read_receipt(self, chat_id: str, msg_id: str) -> None:
        if not msg_id:
            return
        try:
            await self._bridge.send_read_receipt(jid=chat_id, message_ids=[msg_id])
        except Exception:
            logger.debug(f"[WhatsApp] Read receipt failed for {msg_id}", exc_info=True)

    async def _enrich_with_vision(self, channel_msg: ChannelMessage, raw_payload: dict) -> None:
        try:
            for attachment in channel_msg.attachments:
                if attachment.type in ("image", "sticker") and attachment.url:
                    description = await self._sticker_vision.describe_sticker(attachment.url)
                    if description:
                        channel_msg.metadata["vision_description"] = description
                        logger.debug(f"[WhatsApp] Vision enriched: {description[:100]}")
                        break
                elif attachment.type == "audio" and attachment.url:
                    transcription = await self._sticker_vision.transcribe_audio(attachment.url)
                    if transcription:
                        channel_msg.metadata["audio_transcription"] = transcription
                        logger.debug(f"[WhatsApp] Audio transcription: {transcription[:100]}")
                        break
        except Exception:
            logger.debug("[WhatsApp] Vision enrichment failed", exc_info=True)

    def _build_inbound_pipeline(self) -> InboundPipeline:
        pipeline = InboundPipeline()
        pipeline.add_step(self._check_echo, "echo_filter")
        pipeline.add_step(self._check_dedupe, "dedupe")
        pipeline.add_step(self._check_button_dedupe, "button_dedupe")
        pipeline.add_step(self._check_security, "security")
        return pipeline

    def _check_echo(self, payload: dict) -> PipelineResult:
        key = payload.get("key", {})
        msg = payload.get("message", {})
        remote_jid = key.get("remoteJid", "")
        text = msg.get("conversation", "")
        if not text:
            text = (msg.get("extendedTextMessage") or {}).get("text", "")

        if self._echo_filter.is_echo(remote_jid, text):
            return PipelineResult(action=PipelineAction.DROP, reason="echo")
        return PipelineResult(action=PipelineAction.ACCEPT)

    def _check_dedupe(self, payload: dict) -> PipelineResult:
        msg_id = payload.get("key", {}).get("id", "")
        if not msg_id:
            return PipelineResult(action=PipelineAction.ACCEPT)
        if self._deduplicator.is_duplicate(msg_id):
            return PipelineResult(action=PipelineAction.DROP, reason="duplicate")
        return PipelineResult(action=PipelineAction.ACCEPT)

    def _check_button_dedupe(self, payload: dict) -> PipelineResult:
        msg = payload.get("message", {})
        button_msg = msg.get("buttonsResponseMessage") or msg.get("templateButtonReplyMessage")
        if not button_msg:
            return PipelineResult(action=PipelineAction.ACCEPT)

        sender = payload.get("key", {}).get("remoteJid", "")
        button_id = button_msg.get("selectedButtonId", "")
        if not button_id:
            button_id = button_msg.get("selectedId", "")

        if not button_id:
            return PipelineResult(action=PipelineAction.ACCEPT)

        if self._button_deduplicator.is_duplicate(sender, button_id):
            return PipelineResult(action=PipelineAction.DROP, reason="button_duplicate")
        return PipelineResult(action=PipelineAction.ACCEPT)

    def _check_security(self, payload: dict) -> PipelineResult:
        from_me = payload.get("key", {}).get("fromMe", False)
        if from_me:
            if self._self_chat_mode:
                return PipelineResult(action=PipelineAction.ACCEPT)
            return PipelineResult(action=PipelineAction.DROP, reason="self_message")

        remote_jid = payload.get("key", {}).get("remoteJid", "")
        sender = remote_jid.split("@")[0]

        if "@g.us" in remote_jid:
            if not self._per_group_config.is_enabled(remote_jid):
                return PipelineResult(action=PipelineAction.DROP, reason="group_disabled")
            if self._per_group_config.require_mention(remote_jid):
                msg = payload.get("message", {})
                ext_text = msg.get("extendedTextMessage", {})
                context_info = ext_text.get("contextInfo", {})
                mentioned_jids = context_info.get("mentionedJid", []) or []
                if not any(self._self_jid and mj == self._self_jid for mj in mentioned_jids):
                    return PipelineResult(action=PipelineAction.DROP, reason="require_mention_not_met")
            allowed, reason = self._security.check_group_access(remote_jid)
            if not allowed:
                logger.debug(f"[WhatsApp] Group access denied for {remote_jid}: {reason}")
                return PipelineResult(action=PipelineAction.DROP, reason=reason or "group_blocked")
        else:
            if not self._per_dm_config.is_enabled(sender):
                return PipelineResult(action=PipelineAction.DROP, reason="dm_disabled")
            if self._security.dm_policy == DmPolicy.PAIRING and not self._pairing.is_paired(sender):
                logger.debug(f"[WhatsApp] DM pairing required for {sender}")
                return PipelineResult(action=PipelineAction.DROP, reason="dm_not_paired")
            allowed, reason = self._security.check_dm_access(sender)
            if not allowed:
                logger.debug(f"[WhatsApp] DM access denied for {sender}: {reason}")
                return PipelineResult(action=PipelineAction.DROP, reason=reason or "dm_blocked")

        return PipelineResult(action=PipelineAction.ACCEPT)

    def _setup_monitor_handler(self) -> None:
        self._monitor.on_raw_message(self._handle_sse_event)

    async def _on_bridge_unhealthy(self, error: str) -> None:
        logger.warning(f"[WhatsApp] Bridge unhealthy for extended period: {error}, attempting recovery")
        self._status = ChannelStatus.ERROR
        self._connection_ctrl.transition(ConnectionState.RECONNECTING)
        if self._on_connection_change:
            await self._on_connection_change(
                {
                    "status": "error",
                    "error": f"Bridge unhealthy: {error}",
                }
            )

    async def _on_watchdog_timeout(self) -> None:
        logger.warning("[WhatsApp] Watchdog timeout, bridge may be unresponsive")
        self._status = ChannelStatus.ERROR
        self._connection_ctrl.transition(ConnectionState.RECONNECTING)
        if self._on_connection_change:
            await self._on_connection_change(
                {
                    "status": "error",
                    "error": "Watchdog timeout - bridge unresponsive",
                }
            )

    async def _send_with_retry(
        self,
        jid: str,
        content: str,
        reply_to: str | None = None,
        silent: bool = False,
        max_attempts: int = 3,
    ) -> DeliveryResult:
        last_error: str | None = None
        for attempt in range(1, max_attempts + 1):
            try:
                result = await self._bridge.send_message(
                    jid=jid,
                    content=content,
                    reply_to=reply_to,
                    silent=silent,
                )
                if result.success and result.message_id:
                    self._sent_message_cache.put(
                        result.message_id,
                        jid,
                        {"content": content[:200], "reply_to": reply_to},
                    )
                if result.success:
                    return result
                last_error = result.error or "unknown"
            except aiohttp.ClientConnectorError as e:
                last_error = f"Bridge connection failed: {e}"
                logger.warning(
                    f"[WhatsApp] send attempt {attempt}/{max_attempts} failed - bridge connection error for {jid}: {e}"
                )
            except TimeoutError as e:
                last_error = str(e)
                logger.warning(f"[WhatsApp] send attempt {attempt}/{max_attempts} failed - timeout for {jid}: {e}")
            except Exception as e:
                last_error = str(e)
                logger.warning(f"[WhatsApp] send attempt {attempt}/{max_attempts} failed for {jid}: {e}")

            if attempt < max_attempts:
                delay_ms = 500 * attempt
                logger.info(f"[WhatsApp] Retrying send to {jid} in {delay_ms}ms (attempt {attempt})")

                await asyncio.sleep(delay_ms / 1000)

        logger.error(f"[WhatsApp] send failed after {max_attempts} attempts for {jid}")
        if self._error_policy.should_notify(jid, last_error or "send_failed"):
            last_error = self._error_policy.format_error_message(last_error or "send failed")
        return DeliveryResult(success=False, error=last_error or "send failed")

    async def get_user_info(self, channel_user_id: str) -> dict[str, Any]:
        phone = normalize_phone(channel_user_id)
        jid = f"{phone}@s.whatsapp.net"
        try:
            avatar_url = await self._bridge.get_profile_picture(jid)
        except Exception:
            avatar_url = None
        return {
            "phone": phone,
            "jid": jid,
            "avatar_url": avatar_url,
        }

    async def get_groups(self) -> dict[str, Any]:
        return await self._bridge.get_groups()

    async def get_group_info(self, group_jid: str) -> dict[str, Any]:
        return await self._bridge.get_group_info(group_jid)

    async def wait_scan(self, timeout: float = 120.0) -> dict[str, Any]:
        return await self._bridge.wait_scan(timeout)

    async def detect_whatsapp_linked(self) -> bool:
        from .logout_security import validate_credential_freshness
        from .auth_resolve import resolve_auth_dir

        auth_dir = resolve_auth_dir(self.channel_id, self.config)
        if not validate_credential_freshness(auth_dir):
            return False
        try:
            health = await self._bridge.health_check()
            return health.status == "healthy"
        except Exception:
            return False

    async def get_qr_status(self) -> dict[str, Any]:
        return await self._bridge.get_qr_status()

    async def logout(self) -> dict[str, Any]:
        from .logout_security import perform_logout_cleanup
        from .auth_resolve import resolve_auth_dir

        result = await self._bridge.logout()
        auth_dir = resolve_auth_dir(self.channel_id, self.config)
        perform_logout_cleanup(auth_dir)
        self._connection_ctrl.transition(ConnectionState.LOGGED_OUT)
        return result

    async def get_message_history(self, jid: str, limit: int = 50, before: str | None = None) -> dict[str, Any]:
        return await self._bridge.get_message_history(jid, limit=limit, before=before)

    def thread_key_for(self, jid: str) -> str:
        scope = resolve_session_scope(self.config)
        return jid_to_thread_key(self.channel_id, jid, scope)

    def pair_user(self, phone_number: str, code: str, timeout: float = 300) -> None:
        self._pairing.create_pair_request(phone_number, code, timeout)

    def confirm_pair(self, phone_number: str) -> bool:
        return self._pairing.confirm_pair(phone_number)

    def is_paired(self, phone_number: str) -> bool:
        return self._pairing.is_paired(phone_number)

    def add_to_allowlist(self, phone_number: str) -> None:
        self._security.add_to_allow_list(phone_number)

    def remove_from_allowlist(self, phone_number: str) -> bool:
        return self._security.remove_from_allow_list(phone_number)

    @property
    def security_policy(self) -> WhatsAppSecurityPolicy:
        return self._security

    @property
    def pairing_manager(self) -> PairingManager:
        return self._pairing

    @property
    def connection_controller(self) -> ConnectionController:
        return self._connection_ctrl

    @property
    def last_inbound_at(self) -> float | None:
        return self._last_inbound_at

    @property
    def last_message_at(self) -> float | None:
        return self._last_message_at

    def resolve_system_prompt(self, chat_id: str) -> str | None:
        if "@g.us" in chat_id:
            return self._per_group_config.system_prompt(chat_id)
        sender = chat_id.split("@")[0] if "@" in chat_id else chat_id
        return self._per_dm_config.system_prompt(sender)

    def resolve_system_prompt_for_group(self, group_jid: str) -> str | None:
        return self._per_group_config.system_prompt(group_jid)

    def resolve_system_prompt_for_direct(self, phone: str) -> str | None:
        return self._per_dm_config.system_prompt(phone)

    def resolve_quoted_message_key(self, chat_id: str, quoted_msg_id: str | None = None) -> dict | None:
        return self._inbound_cache.resolve_quoted_message_key(chat_id, quoted_msg_id)

    @property
    def inbound_cache(self) -> InboundMessageCache:
        return self._inbound_cache

    @property
    def contact_directory(self) -> ContactDirectory:
        return self._contact_directory

    @property
    def self_chat_mode(self) -> bool:
        return self._self_chat_mode

    @property
    def default_target(self) -> str | None:
        return self._default_to

    @property
    def agent_reaction_guidance(self) -> str | None:
        return self.config.get("agentReactionGuidance")

    def resolve_inbound_debounce_ms(self, account_id: str | None = None) -> float:
        accounts_cfg = self.config.get("accounts", {})
        if account_id and isinstance(accounts_cfg, dict):
            acct = accounts_cfg.get(account_id, {})
            if isinstance(acct, dict) and "debounceWindow" in acct:
                return float(acct["debounceWindow"]) * 1000
        return self.config.get("debounceWindow", 2.0) * 1000

    @property
    def has_capability(self):
        return self.channel_meta.has_capability