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

from __future__ import annotations

import asyncio
import json
import os
import re
import threading
import time
from collections.abc import AsyncIterator
from typing import Any, ClassVar

from yuxi.channels.adapters.line.formatter import LINEMessageFormatter
from yuxi.channels.adapters.line.markdown_to_line import extract_flex_messages_from_markdown
from yuxi.channels.adapters.line.normalizer import LINEEventNormalizer
from yuxi.channels.adapters.line.approval import LINEApprovalAdapter
from yuxi.channels.adapters.line.probe import probe_line_bot
from yuxi.channels.adapters.line.send import LINESender
from yuxi.channels.adapters.line.webhook import (
    LINE_SIGNATURE_HEADER,
    MultiAccountSignatureRouter,
    WebhookReplayGuard,
    validate_line_signature,
)
from yuxi.channels.base import BaseChannelAdapter
from yuxi.channels.capabilities import ChannelCapabilities
from yuxi.channels.exceptions import (
    ChannelAuthenticationError,
)
from yuxi.channels.meta import ChannelMeta
from yuxi.channels.models import (
    ChannelAccountSnapshot,
    ChannelIdentity,
    ChannelMessage,
    ChannelResponse,
    ChannelStatus,
    ChannelType,
    DeliveryResult,
    HealthStatus,
    MentionsInfo,
)
from yuxi.channels.registry import register_builtin_adapter
from yuxi.utils.datetime_utils import utc_now_naive
from yuxi.utils.logging_config import logger


def _is_reply_token_expired(error: str | None) -> bool:
    if not error:
        return False
    error_lower = error.lower()
    return any(kw in error_lower for kw in ("expired", "invalid reply token", "reply token"))


def _is_auth_error(error: str | None) -> bool:
    if not error:
        return False
    error_lower = error.lower()
    return any(kw in error_lower for kw in ("401", "authentication", "unauthorized"))


def _is_comm_channel_disabled(error: str | None) -> bool:
    if not error:
        return False
    error_lower = error.lower()
    return any(kw in error_lower for kw in ("disabled", "communication channel", "not enabled"))


def _is_rate_limited(error: str | None) -> bool:
    if not error:
        return False
    error_lower = error.lower()
    return any(kw in error_lower for kw in ("429", "rate limit", "rate limited", "too many requests"))


def _is_network_error(error: str | None) -> bool:
    if not error:
        return False
    error_lower = error.lower()
    return any(kw in error_lower for kw in ("network", "timeout", "connect", "dns", "refused", "unreachable"))


def _classify_send_error(error: str | None) -> str:
    if not error:
        return "unknown"
    if _is_auth_error(error):
        return "auth"
    if _is_reply_token_expired(error):
        return "reply_token_expired"
    if _is_comm_channel_disabled(error):
        return "channel_disabled"
    if _is_rate_limited(error):
        return "rate_limited"
    if _is_network_error(error):
        return "network"
    error_lower = error.lower()
    if "500" in error_lower or "server error" in error_lower:
        return "server_error"
    if "403" in error_lower or "forbidden" in error_lower:
        return "forbidden"
    return "unknown"


@register_builtin_adapter
class LINEAdapter(BaseChannelAdapter):
    channel_id: ClassVar[str] = "line"
    channel_type: ClassVar[ChannelType] = ChannelType.LINE
    webhook_path: ClassVar[str | None] = "line/callback"

    text_chunk_limit: ClassVar[int] = 5000
    supports_markdown: ClassVar[bool] = True
    supports_streaming: ClassVar[bool] = True
    streaming_modes: ClassVar[list[str]] = ["off", "loading_animation", "chunked"]
    max_media_size_mb: ClassVar[int] = 10

    capabilities = ChannelCapabilities(
        chat_types=["direct", "group"],
        polls=False,
        reactions=False,
        edit=False,
        unsend=False,
        reply=True,
        media=True,
        group_management=False,
        pin=False,
        supports_markdown=True,
        supports_streaming=True,
        streaming_modes=["off", "loading_animation", "chunked"],
        block_streaming=True,
        text_chunk_limit=5000,
        max_media_size_mb=10,
    )
    meta = ChannelMeta(
        id="line",
        label="LINE",
        selection_label="LINE (Messaging API)",
        detail_label="LINE Messaging API Bot",
        blurb="通过 LINE Messaging API 连接 LINE 官方账号，支持文本、媒体、Flex Message、Rich Menu 等功能",
        order=60,
        docs_path="/channels/line",
        system_image="line.svg",
        aliases=["line-bot", "line-messaging"],
    )

    def __init__(self, config: dict[str, Any] | None = None):
        super().__init__(config)
        self._status = ChannelStatus.DISCONNECTED
        self._sender: LINESender | None = None
        self._normalizer = LINEEventNormalizer(channel_id=self.channel_id)
        self._formatter = LINEMessageFormatter()
        self._bot_info: dict[str, Any] = {}
        self._connected_at: float | None = None
        self._self_user_id: str | None = None
        self._config_account: dict[str, Any] = {}
        self._cached_token: str | None = None
        self._cached_secret: str | None = None
        self._token_source: str = "unknown"
        self._last_reply_token: str | None = None
        self._token_lock = threading.Lock()

        self.dm_policy: str = config.get("dm_policy", "open") if config else "open"
        self.group_policy: str = config.get("group_policy", "open") if config else "open"
        self._dm_allow_from: set[str] = set(config.get("allow_from", []) if config else [])
        self._dm_pending_pairing: dict[str, str] = {}
        self._groups_config: dict[str, dict] = {}
        if config and config.get("groups"):
            for g in config["groups"]:
                gid = g.get("id", "")
                if gid:
                    self._groups_config[gid] = {
                        "enabled": g.get("enabled", True),
                        "require_mention": g.get("require_mention", False),
                        "system_prompt": g.get("system_prompt"),
                        "skills": g.get("skills", []),
                        "allow_from": g.get("allow_from"),
                    }

        self._seen_webhook_ids: set[str] = set()
        self._seen_message_ids: set[str] = set()
        self._sent_message_cache: dict[str, dict] = {}
        self._message_queue: asyncio.Queue[ChannelMessage] = asyncio.Queue()
        self._queue_task: asyncio.Task | None = None
        self._last_message_at: float | None = None
        self._last_error: str | None = None
        self._reconnect_attempts: int = 0
        self._streaming_states: dict[str, dict] = {}
        self._reaction_cache: dict[str, list[dict]] = {}
        self._poll_results: dict[str, dict] = {}
        self._profile_cache: dict[str, dict] = {}
        self._group_info_cache: dict[str, dict] = {}
        self._metrics: dict[str, Any] = {
            "messages_sent": 0,
            "messages_failed": 0,
            "streaming_sessions": 0,
            "total_latency_sum": 0.0,
            "error_counts": {},
            "started_at": time.time(),
        }

        self._replay_guard = WebhookReplayGuard()
        self._signature_router = MultiAccountSignatureRouter()

        self.thread_bindings_enabled: bool = (
            config.get("thread_bindings", {}).get("enabled", False) if config else False
        )
        self.thread_bindings_idle_hours: float = config.get("thread_bindings", {}).get("idle_hours", 6) if config else 6
        self.thread_bindings_max_age_hours: float = (
            config.get("thread_bindings", {}).get("max_age_hours", 72) if config else 72
        )
        self.thread_bindings_spawn_subagent: bool = (
            config.get("thread_bindings", {}).get("spawn_subagent_sessions", False) if config else False
        )
        self.thread_bindings_spawn_acp: bool = (
            config.get("thread_bindings", {}).get("spawn_acp_sessions", False) if config else False
        )

        self.conversation_bindings: dict = config.get("conversation_bindings", {}) if config else {}
        self.default_account: str | None = config.get("default_account") if config else None
        self.response_prefix: str = config.get("response_prefix", "") if config else ""
        self.media_max_mb: int = config.get("media_max_mb", 10) if config else 10
        self._agent_prompt: str | None = config.get("agent_prompt") if config else None

        self._skip_message_history: list[dict] = []
        self._target_id_re = re.compile(r"^[UCR][a-f0-9]{32}$|^line:", re.IGNORECASE)

        self._loading_animation_tasks: dict[str, asyncio.Task] = {}
        self._approval: LINEApprovalAdapter | None = None

    @property
    def status(self) -> ChannelStatus:
        return self._status

    async def _resolve_token_and_secret(self, account_id: str | None = None) -> tuple[str, str]:
        if account_id is None and self._cached_token is not None:
            return self._cached_token, self._cached_secret

        account_config = self.config.get("accounts", {})
        if account_id:
            account = account_config.get(account_id, {})
        else:
            account = account_config.get("default", {})
        self._config_account = account

        token = account.get("channel_access_token", "")
        token_source = "config"
        if not token:
            token = os.getenv("LINE_CHANNEL_ACCESS_TOKEN", "")
            token_source = "env"
        if not token:
            token_file = account.get("token_file", "")
            if not token_file:
                token_file = self.config.get("token_file", "")
            if token_file:
                token = await self._read_file_credential(token_file)
                token_source = "file"
        secret = account.get("channel_secret", "")
        if not secret:
            secret = os.getenv("LINE_CHANNEL_SECRET", "")
        if not secret:
            secret_file = account.get("secret_file", "")
            if not secret_file:
                secret_file = self.config.get("secret_file", "")
            if secret_file:
                secret = await self._read_file_credential(secret_file)
        if account_id is None:
            self._cached_token = token
            self._cached_secret = secret
            self._token_source = token_source
        return token, secret

    @staticmethod
    async def _read_file_credential(file_path: str) -> str:
        loop = asyncio.get_event_loop()
        content = await loop.run_in_executor(None, lambda: open(file_path, encoding="utf-8").read().strip())
        return content

    def list_account_ids(self) -> list[str]:
        accounts = self.config.get("accounts", {})
        return [k for k in accounts if k != "default" and isinstance(accounts[k], dict)]

    async def connect(self) -> None:
        self._status = ChannelStatus.CONNECTING
        logger.info(f"[LINE] Starting channel '{self.config.get('name', self.channel_id)}'")

        token, secret = await self._resolve_token_and_secret()
        if not token:
            raise ChannelAuthenticationError("LINE Channel Access Token not configured")
        if not secret:
            raise ChannelAuthenticationError("LINE Channel Secret not configured")

        proxy_url = self.config.get("proxy")
        self._sender = LINESender(token, proxy=proxy_url)
        await self._sender.__aenter__()

        info = await self._sender.get_bot_info()
        if not info:
            await self._sender.__aexit__()
            raise ChannelAuthenticationError("LINE Bot verification failed: unable to get bot info")

        self._bot_info = {
            "display_name": info.get("displayName", ""),
            "user_id": info.get("userId", ""),
            "picture_url": info.get("pictureUrl", ""),
        }
        self._self_user_id = info.get("userId", "")

        self._signature_router.register_account("default", secret)

        for account_id in self.list_account_ids():
            _, account_secret = await self._resolve_token_and_secret(account_id)
            if account_secret:
                self._signature_router.register_account(account_id, account_secret)

        self._connected_at = time.time()
        self._status = ChannelStatus.CONNECTED
        self._queue_task = asyncio.ensure_future(self._queue_consumer())
        self._approval = LINEApprovalAdapter(self)
        logger.info(f"[LINE] Bot '{self._bot_info.get('display_name', '')}' ({self._self_user_id}) connected")

    async def disconnect(self) -> None:
        self._status = ChannelStatus.DISCONNECTED
        if self._queue_task:
            self._queue_task.cancel()
            try:
                await self._queue_task
            except (asyncio.CancelledError, Exception):
                pass
            self._queue_task = None
        if self._sender:
            await self._sender.__aexit__()
            self._sender = None
        self._bot_info = {}
        self._seen_webhook_ids.clear()
        self._seen_message_ids.clear()
        self._sent_message_cache.clear()
        self._replay_guard.clear()
        self._signature_router.clear()
        for task in self._loading_animation_tasks.values():
            task.cancel()
        self._loading_animation_tasks.clear()
        logger.info("[LINE] adapter disconnected")

    async def logout_account(self, account_id: str | None = None) -> None:
        if account_id is None:
            self._cached_token = None
            self._cached_secret = None
            self._replay_guard.clear()
            self._signature_router.clear()
            self._seen_webhook_ids.clear()
            self._seen_message_ids.clear()
            logger.info("[LINE] all accounts logged out")
        else:
            self._signature_router.unregister_account(account_id)
            accounts = self.config.get("accounts", {})
            if account_id in accounts:
                acct = accounts[account_id]
                acct.pop("channel_access_token", None)
                acct.pop("channel_secret", None)
                acct.pop("token_file", None)
                acct.pop("secret_file", None)
            logger.info(f"[LINE] account '{account_id}' logged out")

    async def send(self, response: ChannelResponse) -> DeliveryResult:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            self._metrics["messages_failed"] += 1
            return DeliveryResult(success=False, error="LINE not connected")

        chat_id = response.identity.channel_chat_id
        content = response.content
        if self.response_prefix and content:
            if not content.startswith(self.response_prefix):
                content = self.response_prefix + content

        messages = self._build_send_payload(response)

        reply_token = response.metadata.get("reply_token")
        if reply_token:
            result = (
                await self._sender.reply_message(reply_token, messages) if messages else DeliveryResult(success=True)
            )
            if not result.success and _is_reply_token_expired(result.error):
                logger.info("[LINE] replyToken expired, falling back to push")
                result = (
                    await self._sender.push_message(chat_id, messages) if messages else DeliveryResult(success=True)
                )
            self._record_result(result)
            if _is_auth_error(result.error):
                await self._auto_disable_graduated("LINE auth error during reply")
            if _is_comm_channel_disabled(result.error):
                await self._auto_disable_graduated("LINE communication channel disabled")
            if result.success and result.message_id:
                self._track_sent_message(result.message_id, chat_id, "reply")
            self._last_message_at = time.time()
            return result

        if not messages:
            return DeliveryResult(success=True)
        result = await self._sender.push_message(chat_id, messages)
        self._record_result(result)
        if _is_auth_error(result.error):
            await self._auto_disable_graduated("LINE auth error during push")
        if _is_comm_channel_disabled(result.error):
            await self._auto_disable_graduated("LINE communication channel disabled")
        if _is_rate_limited(result.error):
            logger.warning(f"[LINE] rate limited during push to {chat_id}")
        if result.error:
            error_category = _classify_send_error(result.error)
            logger.debug(f"[LINE] push error category={error_category}: {result.error}")
        if result.success and result.message_id:
            self._track_sent_message(result.message_id, chat_id, "push")
        self._last_message_at = time.time()
        return result

    def _build_send_payload(self, response: ChannelResponse) -> list[dict]:
        metadata = response.metadata

        flex_contents = metadata.get("flex_contents")
        if flex_contents:
            return [
                {"type": "flex", "altText": metadata.get("alt_text", "Flex Message")[:400], "contents": flex_contents}
            ]

        template = metadata.get("template")
        if template:
            return [{"type": "template", "altText": metadata.get("alt_text", "Template")[:400], "template": template}]

        location = metadata.get("location")
        if location:
            return [
                {
                    "type": "location",
                    "title": location.get("title", "")[:100],
                    "address": location.get("address", "")[:100],
                    "latitude": location.get("latitude", 0),
                    "longitude": location.get("longitude", 0),
                }
            ]

        text_content = response.content
        if self.response_prefix and text_content:
            if not text_content.startswith(self.response_prefix):
                text_content = self.response_prefix + text_content

        quick_replies = metadata.get("quick_replies")
        if quick_replies and not text_content:
            return [{"type": "text", "text": " ", "quickReply": {"items": quick_replies[:13]}}]

        messages = self._formatter.format(response)
        final: list[dict] = []

        markdown_flex = []
        if response.content and self.supports_markdown:
            markdown_flex = extract_flex_messages_from_markdown(response.content)

        for msg in messages:
            if isinstance(msg, dict) and msg.get("type") == "flex":
                final.append(msg)
        for msg in markdown_flex:
            if isinstance(msg, dict) and msg.get("type") == "flex" and msg not in final:
                final.append(msg)
        for msg in messages:
            if isinstance(msg, dict) and msg.get("type") == "template" and msg not in final:
                final.append(msg)
        for msg in messages:
            if isinstance(msg, dict) and msg.get("type") == "location" and msg not in final:
                final.append(msg)
        for msg in messages:
            if isinstance(msg, dict) and msg.get("type") == "text" and msg not in final:
                final.append(msg)
        for msg in messages:
            if isinstance(msg, dict) and msg not in final:
                final.append(msg)

        if quick_replies and final:
            last = final[-1]
            if isinstance(last, dict) and last.get("type") == "text":
                last["quickReply"] = {"items": quick_replies[:13]}
            elif isinstance(last, dict) and last.get("type") in ("flex", "template", "image", "video"):
                final.append({"type": "text", "text": " ", "quickReply": {"items": quick_replies[:13]}})

        return final[:5]

    def _record_result(self, result: DeliveryResult) -> None:
        if result.success:
            self._metrics["messages_sent"] += 1
        else:
            self._metrics["messages_failed"] += 1
            category = _classify_send_error(result.error)
            self._metrics["error_counts"][category] = self._metrics["error_counts"].get(category, 0) + 1

    def get_metrics(self) -> dict[str, Any]:
        uptime = time.time() - self._metrics["started_at"]
        metrics = dict(self._metrics)
        total = metrics["messages_sent"] + metrics["messages_failed"]
        metrics["uptime_seconds"] = uptime
        metrics["total_messages"] = total
        metrics["success_rate"] = metrics["messages_sent"] / total if total > 0 else 1.0
        return metrics

    async def send_media(self, chat_id: str, media_type: str, data: Any, **kwargs) -> DeliveryResult:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return DeliveryResult(success=False, error="LINE not connected")

        url = data if isinstance(data, str) else kwargs.get("url", "")
        if not url:
            return DeliveryResult(
                success=False,
                error="LINE media send requires HTTPS URL. Provide URL as 'data' or 'url' kwarg.",
            )

        safe_url = self._ensure_https_url(url)
        if not safe_url:
            return DeliveryResult(
                success=False,
                error="LINE media URL must be a valid HTTPS URL (max 2000 chars)",
            )

        if media_type == "image":
            preview_url = kwargs.get("preview_url", safe_url)
            safe_preview = self._ensure_https_url(str(preview_url)) or safe_url
            messages = [
                {
                    "type": "image",
                    "originalContentUrl": safe_url,
                    "previewImageUrl": safe_preview,
                }
            ]
        elif media_type == "video":
            preview_url = kwargs.get("preview_url", "")
            safe_preview = self._ensure_https_url(str(preview_url)) if preview_url else ""
            tracking_id = kwargs.get("tracking_id")
            msg: dict = {
                "type": "video",
                "originalContentUrl": safe_url,
                "previewImageUrl": safe_preview,
            }
            if tracking_id:
                msg["trackingId"] = tracking_id
            messages = [msg]
        elif media_type == "audio":
            duration = kwargs.get("duration", 60000)
            messages = [
                {
                    "type": "audio",
                    "originalContentUrl": safe_url,
                    "duration": duration,
                }
            ]
        elif media_type == "file":
            file_name = kwargs.get("file_name", kwargs.get("filename", "file"))
            file_size = kwargs.get("file_size", kwargs.get("size", 0))
            messages = [
                {
                    "type": "file",
                    "originalContentUrl": safe_url,
                    "fileName": str(file_name)[:600],
                    "fileSize": int(file_size) if file_size else 0,
                }
            ]
        else:
            return DeliveryResult(
                success=False,
                error=f"LINE media type '{media_type}' not supported. Use image/video/audio/file.",
            )

        reply_token = kwargs.get("reply_token")
        if reply_token:
            return await self._sender.reply_message(reply_token, messages)
        return await self._sender.push_message(chat_id, messages)

    async def download_media(self, file_id: str) -> bytes:
        if not self._sender:
            raise RuntimeError("LINE adapter not connected")
        content = await self._sender.get_message_content(file_id)
        if content is None:
            raise RuntimeError(f"Failed to download LINE message content: {file_id}")
        return content

    async def send_stream_chunk(self, chat_id: str, msg_id: str, chunk: str, finished: bool) -> DeliveryResult:
        state = self._get_or_create_stream_state(chat_id, msg_id)
        state["accumulated"] += chunk
        state["chunks_sent"] += 1

        identity = self._build_stream_identity(chat_id, msg_id)
        with self._token_lock:
            reply_token = self._last_reply_token
        metadata = {}
        if reply_token:
            metadata["reply_token"] = reply_token
        response = ChannelResponse(identity=identity, content=chunk, metadata=metadata)
        result = await self.send(response)

        if finished:
            state["finished"] = True
            state["finished_at"] = time.time()
            self._streaming_states.pop(f"{chat_id}:{msg_id}", None)

        return result

    async def send_stream_start(self, chat_id: str, msg_id: str) -> None:
        state = self._get_or_create_stream_state(chat_id, msg_id)
        state["status"] = "streaming"
        await self.send_loading_animation(chat_id, 60)

    async def send_reasoning_chunk(self, chat_id: str, msg_id: str, chunk: str, finished: bool) -> DeliveryResult:
        state = self._get_or_create_stream_state(chat_id, msg_id)
        state["reasoning_mode"] = True
        state["reasoning_accumulated"] += chunk

        wrapped = f"💭 {chunk}"
        return await self.send_stream_chunk(chat_id, msg_id, wrapped, finished)

    def _get_or_create_stream_state(self, chat_id: str, msg_id: str) -> dict:
        key = f"{chat_id}:{msg_id}"
        if key not in self._streaming_states:
            self._streaming_states[key] = {
                "status": "idle",
                "started_at": time.time(),
                "accumulated": "",
                "reasoning_mode": False,
                "reasoning_accumulated": "",
                "chunks_sent": 0,
                "finished": False,
                "finished_at": None,
            }
        return self._streaming_states[key]

    def get_stream_state(self, chat_id: str, msg_id: str) -> dict | None:
        key = f"{chat_id}:{msg_id}"
        return self._streaming_states.get(key)

    async def cancel_stream(self, chat_id: str, msg_id: str) -> None:
        key = f"{chat_id}:{msg_id}"
        state = self._streaming_states.pop(key, None)
        if state:
            state["status"] = "cancelled"
            state["finished"] = True
            state["finished_at"] = time.time()
            logger.debug(f"[LINE] stream cancelled: {key}")

    async def send_loading_animation(self, chat_id: str, seconds: int = 20) -> None:
        if self._sender and _is_dm_chat(chat_id):
            await self._sender.show_loading_animation(chat_id, seconds)

    async def _loading_animation_keepalive(self, chat_id: str) -> None:
        if not _is_dm_chat(chat_id):
            return
        try:
            while True:
                await asyncio.sleep(18)
                if chat_id not in self._loading_animation_tasks:
                    break
                await self._sender.show_loading_animation(chat_id, 20)
        except asyncio.CancelledError:
            pass

    async def start_loading_animation_with_keepalive(self, chat_id: str) -> None:
        if self._sender:
            await self._sender.show_loading_animation(chat_id, 20)
        if chat_id in self._loading_animation_tasks:
            self._loading_animation_tasks[chat_id].cancel()
        self._loading_animation_tasks[chat_id] = asyncio.ensure_future(self._loading_animation_keepalive(chat_id))

    async def stop_loading_animation(self, chat_id: str) -> None:
        task = self._loading_animation_tasks.pop(chat_id, None)
        if task:
            task.cancel()

    async def send_multicast(self, user_ids: list[str], response: ChannelResponse) -> DeliveryResult:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return DeliveryResult(success=False, error="LINE not connected")

        messages = self._formatter.format(response)
        return await self._sender.multicast_message(user_ids, messages)

    async def send_broadcast(self, response: ChannelResponse) -> DeliveryResult:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return DeliveryResult(success=False, error="LINE not connected")

        messages = self._formatter.format(response)
        return await self._sender.broadcast_message(messages)

    async def mark_as_read(self, chat_id: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.mark_as_read(chat_id)

    async def validate_messages(
        self, messages: list[dict], validate_type: str = "push", user_ids: list[str] | None = None
    ) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        if validate_type == "push":
            return await self._sender.validate_push(messages)
        if validate_type == "reply":
            return await self._sender.validate_reply(messages)
        if validate_type == "multicast":
            return await self._sender.validate_multicast(user_ids or [], messages)
        if validate_type == "broadcast":
            return await self._sender.validate_broadcast(messages)
        return False

    async def list_rich_menus(self) -> list[dict] | None:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return None
        return await self._sender.get_rich_menus()

    async def create_rich_menu(self, rich_menu_def: dict, image_bytes: bytes | None = None) -> str | None:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return None
        menu_id = await self._sender.create_rich_menu(rich_menu_def)
        if menu_id and image_bytes:
            ok = await self._sender.set_rich_menu_image(menu_id, image_bytes)
            if not ok:
                logger.warning(f"LINE rich menu {menu_id} created but image upload failed")
        return menu_id

    async def delete_rich_menu(self, rich_menu_id: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.delete_rich_menu(rich_menu_id)

    async def link_rich_menu(self, user_id: str, rich_menu_id: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.link_rich_menu_to_user(user_id, rich_menu_id)

    async def link_rich_menu_bulk(self, user_ids: list[str], rich_menu_id: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.link_rich_menu_to_users(user_ids, rich_menu_id)

    async def unlink_rich_menu(self, user_id: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.unlink_rich_menu_from_user(user_id)

    async def set_default_rich_menu(self, rich_menu_id: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.set_default_rich_menu(rich_menu_id)

    async def cancel_default_rich_menu(self) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.cancel_default_rich_menu()

    async def link_rich_menu_bulk(self, user_ids: list[str], rich_menu_id: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.link_rich_menu_to_multiple_users(user_ids, rich_menu_id)

    async def unlink_rich_menu_bulk(self, user_ids: list[str]) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.unlink_rich_menu_from_multiple_users(user_ids)

    async def get_rich_menu_image(self, rich_menu_id: str) -> bytes | None:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return None
        return await self._sender.get_rich_menu_image(rich_menu_id)

    async def validate_rich_menu_object(self, rich_menu: dict) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.validate_rich_menu_object(rich_menu)

    async def create_rich_menu_alias(self, alias_name: str, rich_menu_id: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.create_rich_menu_alias(alias_name, rich_menu_id)

    async def delete_rich_menu_alias(self, alias_name: str) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        return await self._sender.delete_rich_menu_alias(alias_name)

    async def get_rich_menu_by_alias(self, alias_name: str) -> dict | None:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return None
        return await self._sender.get_rich_menu_by_alias(alias_name)

    @staticmethod
    def create_default_menu_config() -> dict:
        return {
            "size": {"width": 2500, "height": 1686},
            "selected": True,
            "name": "default",
            "chatBarText": "打开菜单",
            "areas": [
                {
                    "bounds": {"x": 0, "y": 0, "width": 833, "height": 843},
                    "action": {"type": "message", "text": "帮助"},
                },
                {
                    "bounds": {"x": 833, "y": 0, "width": 833, "height": 843},
                    "action": {"type": "message", "text": "功能"},
                },
                {
                    "bounds": {"x": 1666, "y": 0, "width": 834, "height": 843},
                    "action": {"type": "message", "text": "设置"},
                },
                {
                    "bounds": {"x": 0, "y": 843, "width": 833, "height": 843},
                    "action": {"type": "uri", "label": "官网", "uri": "https://line.me"},
                },
                {
                    "bounds": {"x": 833, "y": 843, "width": 833, "height": 843},
                    "action": {"type": "message", "text": "搜索"},
                },
                {
                    "bounds": {"x": 1666, "y": 843, "width": 834, "height": 843},
                    "action": {"type": "message", "text": "关于"},
                },
            ],
        }

    async def send_reaction(self, chat_id: str, msg_id: str, emoji: str) -> DeliveryResult:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return DeliveryResult(success=False, error="LINE not connected")

        cache_key = f"{chat_id}:{msg_id}"
        if cache_key not in self._reaction_cache:
            self._reaction_cache[cache_key] = []
        self._reaction_cache[cache_key].append(
            {
                "emoji": emoji,
                "timestamp": time.time(),
            }
        )

        if len(self._reaction_cache) > 1000:
            oldest_keys = sorted(self._reaction_cache.keys())[:500]
            for k in oldest_keys:
                del self._reaction_cache[k]

        messages = [{"type": "text", "text": emoji}]
        return await self._sender.push_message(chat_id, messages)

    def get_reactions(self, msg_id: str, chat_id: str | None = None) -> list[dict]:
        if chat_id:
            key = f"{chat_id}:{msg_id}"
            return self._reaction_cache.get(key, [])
        results = []
        for key, reactions in self._reaction_cache.items():
            if key.endswith(f":{msg_id}"):
                results.extend(reactions)
        return results

    def clear_reactions(self, msg_id: str | None = None) -> None:
        if msg_id:
            keys_to_remove = [k for k in self._reaction_cache if k.endswith(f":{msg_id}")]
            for k in keys_to_remove:
                del self._reaction_cache[k]
        else:
            self._reaction_cache.clear()

    async def send_sticker(
        self, chat_id: str, package_id: str, sticker_id: str, reply_token: str | None = None
    ) -> DeliveryResult:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return DeliveryResult(success=False, error="LINE not connected")
        return await self._sender.send_sticker(chat_id, package_id, sticker_id, reply_token)

    async def create_poll(
        self,
        chat_id: str,
        question: str,
        options: list[str],
        anonymous: bool = False,
        duration_seconds: int = 0,
        allow_multiple: bool = False,
    ) -> DeliveryResult:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return DeliveryResult(success=False, error="LINE not connected")
        if len(options) < 1 or len(options) > 4:
            return DeliveryResult(success=False, error="Poll requires 1-4 options")
        if len(question) > 240:
            question = question[:237] + "..."

        poll_id = f"poll_{int(time.time() * 1000)}_{chat_id[:10]}"
        self._poll_results[poll_id] = {
            "chat_id": chat_id,
            "question": question,
            "options": options,
            "anonymous": anonymous,
            "allow_multiple": allow_multiple,
            "votes": {opt: 0 for opt in options},
            "voters": {},
            "created_at": time.time(),
            "expires_at": time.time() + duration_seconds if duration_seconds > 0 else None,
        }

        actions = []
        for i, opt in enumerate(options[:4]):
            label = opt[:20] if len(opt) > 20 else opt
            actions.append(
                {
                    "type": "postback",
                    "label": label,
                    "data": f"poll_id={poll_id}&answer={i}",
                    "displayText": f"投票: {label}",
                }
            )

        body_sections = [
            {"type": "text", "text": question, "wrap": True, "size": "md"},
            {"type": "separator", "margin": "md"},
        ]
        for i, opt in enumerate(options[:4]):
            idx = ["①", "②", "③", "④"][i]
            body_sections.append(
                {
                    "type": "text",
                    "text": f"{idx} {opt}",
                    "wrap": True,
                    "size": "sm",
                    "margin": "sm",
                }
            )

        bubble = {
            "type": "bubble",
            "header": {
                "type": "box",
                "layout": "vertical",
                "contents": [{"type": "text", "text": "📊 投票", "weight": "bold", "size": "lg", "color": "#ffffff"}],
                "backgroundColor": "#06C755",
            },
            "body": {
                "type": "box",
                "layout": "vertical",
                "contents": body_sections,
            },
            "footer": {
                "type": "box",
                "layout": "vertical",
                "contents": actions,
            },
        }

        message = {
            "type": "flex",
            "altText": f"投票: {question[:40]}",
            "contents": bubble,
        }
        result = await self._sender.push_message(chat_id, [message])
        if result.success and result.message_id:
            self._poll_results[poll_id]["message_id"] = result.message_id
        return result

    def record_vote(self, poll_id: str, option_index: int, voter_id: str) -> dict | None:
        poll = self._poll_results.get(poll_id)
        if not poll:
            return None

        if poll["expires_at"] and time.time() > poll["expires_at"]:
            return None

        if not poll["allow_multiple"] and voter_id in poll["voters"]:
            return None

        if option_index < 0 or option_index >= len(poll["options"]):
            return None

        option_name = poll["options"][option_index]
        poll["votes"][option_name] += 1
        poll["voters"][voter_id] = option_index

        return self.get_poll_results(poll_id)

    def get_poll_results(self, poll_id: str) -> dict | None:
        poll = self._poll_results.get(poll_id)
        if not poll:
            return None

        total_votes = sum(poll["votes"].values())
        return {
            "poll_id": poll_id,
            "question": poll["question"],
            "options": poll["options"],
            "votes": poll["votes"],
            "total_votes": total_votes,
            "voter_count": len(poll["voters"]),
            "anonymous": poll["anonymous"],
            "allow_multiple": poll["allow_multiple"],
            "created_at": poll["created_at"],
            "expires_at": poll["expires_at"],
        }

    def list_active_polls(self, chat_id: str | None = None) -> list[dict]:
        results = []
        for poll_id, poll in self._poll_results.items():
            if chat_id and poll["chat_id"] != chat_id:
                continue
            if poll["expires_at"] and time.time() > poll["expires_at"]:
                continue
            results.append(self.get_poll_results(poll_id))
        return results

    def close_poll(self, poll_id: str) -> dict | None:
        poll = self._poll_results.get(poll_id)
        if not poll:
            return None
        poll["expires_at"] = time.time()
        return self.get_poll_results(poll_id)

    async def _check_dm_access(self, channel_user_id: str) -> tuple[bool, str | None]:
        if self.dm_policy == "disabled":
            return False, "DM access disabled by policy"
        if self.dm_policy == "open":
            return True, None
        if self.dm_policy == "allowlist":
            if channel_user_id in self._dm_allow_from:
                return True, None
            return False, "DM access denied: user not in allowlist"
        if self.dm_policy == "pairing":
            if channel_user_id in self._dm_allow_from:
                return True, None
            if channel_user_id not in self._dm_pending_pairing:
                code = _gen_pairing_code()
                self._dm_pending_pairing[channel_user_id] = code
                await self._send_pairing_prompt(channel_user_id, code)
            return False, "DM pairing required: send pairing code to continue"
        return True, None

    async def _check_group_access(self, chat_id: str, content: str = "") -> tuple[bool, str | None]:
        group_cfg = self._resolve_group_config(chat_id)
        if group_cfg is None:
            return True, None
        if not group_cfg.get("enabled", False):
            return False, "Group not in allowlist"
        if group_cfg.get("require_mention", False):
            if not _bot_mentioned(content, self._self_user_id):
                result = (False, "Bot not mentioned")
                self._skip_message_history.append(
                    {
                        "chat_id": chat_id,
                        "content": content[:200],
                        "skipped_at": time.time(),
                        "reason": "require_mention",
                    }
                )
                return result
        return True, None

    def get_group_system_prompt(self, chat_id: str) -> str | None:
        group_cfg = self._resolve_group_config(chat_id)
        if group_cfg:
            return group_cfg.get("system_prompt")
        return None

    def get_group_skills(self, chat_id: str) -> list[str]:
        group_cfg = self._resolve_group_config(chat_id)
        if group_cfg:
            return group_cfg.get("skills", [])
        return []

    def get_group_allow_from(self, chat_id: str) -> list[str] | None:
        group_cfg = self._resolve_group_config(chat_id)
        if group_cfg:
            return group_cfg.get("allow_from")
        return None

    def get_skip_message_history(self) -> list[dict]:
        result = list(self._skip_message_history)
        return result

    def _resolve_group_config(self, chat_id: str) -> dict | None:
        if self.group_policy == "disabled":
            return {"enabled": False}
        if self.group_policy == "open":
            return None
        if self.group_policy == "allowlist":
            specific = self._groups_config.get(chat_id)
            if specific is not None:
                return specific
            wildcard = self._groups_config.get("*")
            if wildcard is not None:
                return wildcard
            return {"enabled": False}
        return None

    async def _send_pairing_prompt(self, user_id: str, code: str) -> None:
        if not self._sender:
            return
        messages = [
            {
                "type": "text",
                "text": f"👋 你好！请发送配对码 {code} 以完成验证。\n请在聊天中输入: /pair {code}",
            }
        ]
        await self._sender.push_message(f"user_{user_id}", messages)

    async def approve_pairing(self, code: str) -> bool:
        for uid, pending_code in list(self._dm_pending_pairing.items()):
            if pending_code == code:
                self._dm_allow_from.add(uid)
                del self._dm_pending_pairing[uid]
                if self._sender:
                    messages = [{"type": "text", "text": "✅ 配对成功！你现在可以与 Bot 对话了。"}]
                    await self._sender.push_message(f"user_{uid}", messages)
                return True
        return False

    async def _auto_disable(self, reason: str) -> None:
        logger.error(f"[LINE] auto-disabling channel due to: {reason}")
        self._last_error = reason
        self._status = ChannelStatus.ERROR
        if self._queue_task:
            self._queue_task.cancel()
            try:
                await self._queue_task
            except (asyncio.CancelledError, Exception):
                pass
            self._queue_task = None
        if self._sender:
            try:
                await self._sender.__aexit__()
            except Exception:
                pass
            self._sender = None

    async def _queue_consumer(self) -> None:
        while True:
            try:
                message = await self._message_queue.get()
                try:
                    if self._message_handler:
                        await self._message_handler(message)
                except Exception as exc:
                    logger.error(f"[LINE] queue handler failed: {exc}")
                finally:
                    self._message_queue.task_done()
            except asyncio.CancelledError:
                logger.debug("[LINE] message queue consumer cancelled")
                break

    async def enqueue_message(self, message: ChannelMessage) -> None:
        await self._message_queue.put(message)
        logger.debug(f"[LINE] enqueued message for chat={message.identity.channel_chat_id}")

    def _track_sent_message(self, message_id: str, chat_id: str, send_type: str = "push") -> None:
        self._sent_message_cache[message_id] = {
            "chat_id": chat_id,
            "type": send_type,
            "sent_at": time.time(),
            "delivered": time.time(),
            "read": None,
        }
        if len(self._sent_message_cache) > 5000:
            oldest = sorted(self._sent_message_cache.keys())[:2500]
            for k in oldest:
                del self._sent_message_cache[k]

    def _mark_delivered(self, message_id: str) -> None:
        entry = self._sent_message_cache.get(message_id)
        if entry:
            entry["delivered"] = time.time()

    def _mark_read(self, message_id: str) -> None:
        entry = self._sent_message_cache.get(message_id)
        if entry:
            entry["read"] = time.time()

    def _is_duplicate_webhook(self, webhook_event_id: str) -> bool:
        if not webhook_event_id:
            return False
        if webhook_event_id in self._seen_webhook_ids:
            return True
        self._seen_webhook_ids.add(webhook_event_id)
        if len(self._seen_webhook_ids) > 10000:
            self._seen_webhook_ids = set(list(self._seen_webhook_ids)[-5000:])
        return False

    def _is_duplicate_message(self, message_id: str) -> bool:
        if not message_id:
            return False
        if message_id in self._seen_message_ids:
            return True
        self._seen_message_ids.add(message_id)
        if len(self._seen_message_ids) > 10000:
            self._seen_message_ids = set(list(self._seen_message_ids)[-5000:])
        return False

    @staticmethod
    def _ensure_https_url(url: str) -> str | None:
        if not url:
            return None
        if not isinstance(url, str):
            return None
        if len(url) > 2000:
            return None
        if not url.startswith("https://"):
            return None
        from urllib.parse import urlparse

        parsed = urlparse(url)
        hostname = parsed.hostname or ""
        if _is_private_hostname(hostname):
            return None
        return url

    def get_account_snapshot(self) -> ChannelAccountSnapshot:
        from yuxi.channels.models import build_snapshot_from_adapter

        snapshot = build_snapshot_from_adapter(self)
        snapshot.dm_policy = self.dm_policy
        snapshot.group_policy = self.group_policy
        snapshot.allow_from_count = len(self._dm_allow_from)
        snapshot.webhook_path = self.webhook_path or ""
        snapshot.bot = self._bot_info or None
        snapshot.last_message_at = self._last_message_at
        snapshot.last_error = self._last_error
        snapshot.pairing_pending = len(self._dm_pending_pairing)
        snapshot.token_source = self._token_source
        return snapshot

    async def receive(self) -> AsyncIterator[ChannelMessage]:
        return
        yield  # pragma: no cover

    def normalize_inbound(self, raw: bytes) -> ChannelMessage:
        body_str = raw.decode("utf-8") if isinstance(raw, bytes) else raw
        data = json.loads(body_str)
        events = data.get("events", [])

        if not events:
            return ChannelMessage(
                identity=ChannelIdentity(
                    channel_id=self.channel_id,
                    channel_type=self.channel_type,
                    channel_user_id="unknown",
                    channel_chat_id="unknown",
                ),
                content="(empty webhook)",
            )

        primary_msg = self._normalizer.normalize(events[0])

        webhook_id = events[0].get("webhookEventId", "")
        if self._is_duplicate_webhook(webhook_id):
            logger.debug(f"[LINE] duplicate webhook event: {webhook_id}")
        msg_id = primary_msg.identity.channel_message_id
        if msg_id and self._is_duplicate_message(msg_id):
            logger.debug(f"[LINE] duplicate message: {msg_id}")

        content = primary_msg.content

        mentions = _resolve_mentions(content, self._self_user_id, events[0])
        primary_msg.mentions = mentions
        primary_msg.metadata["mentions"] = {
            "mentioned_user_ids": mentions.mentioned_user_ids,
            "is_bot_mentioned": mentions.is_bot_mentioned,
        }

        with self._token_lock:
            self._last_reply_token = primary_msg.metadata.get("reply_token")

        self._last_message_at = time.time()

        for i, event in enumerate(events[1:], start=1):
            msg = self._normalizer.normalize(event)
            event_type_str = event.get("type", "unknown")
            msg.mentions = _resolve_mentions(msg.content, self._self_user_id)
            logger.debug(f"[LINE] dispatching additional event #{i}: {event_type_str}")
            if self._message_handler:
                try:
                    loop = asyncio.get_event_loop()
                    if loop.is_running():
                        asyncio.ensure_future(self._message_handler(msg))
                    else:
                        loop.run_until_complete(self._message_handler(msg))
                except Exception as exc:
                    logger.error(f"[LINE] event handler failed for {event_type_str}: {exc}")

        return primary_msg

    def format_outbound(self, response: ChannelResponse) -> Any:
        return self._formatter.format(response)

    async def health_check(self) -> HealthStatus:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return HealthStatus(status="unhealthy", last_error="Not connected")

        start = time.monotonic()
        try:
            info = await self._sender.get_bot_info()
            latency_ms = (time.monotonic() - start) * 1000

            metadata: dict[str, Any] = {
                "bot_display_name": self._bot_info.get("display_name", ""),
                "bot_user_id": self._self_user_id,
                "dm_policy": self.dm_policy,
                "group_policy": self.group_policy,
                "allow_from_count": len(self._dm_allow_from),
                "group_count": len(self._groups_config),
                "seen_webhook_ids": len(self._seen_webhook_ids),
                "sent_message_cache": len(self._sent_message_cache),
            }

            warnings: list[str] = []
            if self.dm_policy == "allowlist" and len(self._dm_allow_from) == 0:
                warnings.append("DM allowlist is empty — no users can access")
            if self.group_policy == "allowlist" and len(self._groups_config) == 0:
                warnings.append("Group allowlist is empty — no groups can access")
            if self.dm_policy == "pairing":
                pending = len(self._dm_pending_pairing)
                if pending > 0:
                    warnings.append(f"{pending} users pending DM pairing")
            if warnings:
                metadata["warnings"] = warnings

            quota = await self._sender.get_message_quota()
            if quota:
                metadata["message_quota_type"] = quota.get("type", "unknown")
                metadata["message_quota_value"] = quota.get("value")

            consumption = await self._sender.get_message_quota_consumption()
            if consumption:
                metadata["message_usage"] = consumption.get("totalUsage")

            if info:
                return HealthStatus(
                    status="healthy",
                    latency_ms=latency_ms,
                    last_connected_at=utc_now_naive(),
                    metadata=metadata,
                )
            return HealthStatus(status="unhealthy", last_error="Bot info fetch returned empty")
        except Exception as e:
            return HealthStatus(status="unhealthy", last_error=str(e))

    async def verify_webhook_signature(self, headers: dict, body: bytes) -> bool:
        _, secret = await self._resolve_token_and_secret()
        if not secret:
            logger.error("[LINE] webhook: channel_secret not configured, rejecting request")
            return False

        signature = headers.get(LINE_SIGNATURE_HEADER, "")
        if not signature:
            logger.warning("[LINE] webhook: missing X-Line-Signature header")
            return False

        if not validate_line_signature(body, signature, secret):
            matched_account = self._signature_router.match_signature(body, signature)
            if matched_account:
                _, account_secret = await self._resolve_token_and_secret(matched_account)
                if account_secret:
                    logger.info(f"[LINE] webhook matched account '{matched_account}' via signature routing")
                    try:
                        self._replay_guard.check_and_claim(signature)
                    except Exception:
                        logger.warning("[LINE] replay attack detected (multi-account)")
                        return False
                    return True
            logger.warning("[LINE] webhook: invalid signature, rejecting request")
            return False

        try:
            self._replay_guard.check_and_claim(signature)
        except Exception:
            logger.warning("[LINE] replay attack detected")
            return False

        return True

    async def get_user_info(self, channel_user_id: str) -> dict[str, Any]:
        cached = self._profile_cache.get(channel_user_id)
        if cached and time.time() - cached.get("cached_at", 0) < 3600:
            return cached["data"]

        if not self._sender:
            profile = await self._lookup_friends_info(channel_user_id)
            if profile:
                self._cache_profile(channel_user_id, profile)
                return profile
            return cached.get("data", {}) if cached else {}

        profile = await self._sender.get_profile(channel_user_id)
        if profile:
            data = {
                "display_name": profile.get("displayName", ""),
                "user_id": profile.get("userId", channel_user_id),
                "picture_url": profile.get("pictureUrl", ""),
                "status_message": profile.get("statusMessage", ""),
            }
            self._cache_profile(channel_user_id, data)
            return data

        return cached.get("data", {}) if cached else {}

    async def get_group_info(self, group_id: str) -> dict[str, Any]:
        cached = self._group_info_cache.get(group_id)
        if cached and time.time() - cached.get("cached_at", 0) < 3600:
            return cached["data"]

        if not self._sender:
            return {}

        try:
            summary = await self._sender.get_group_summary(group_id)
            if summary:
                data = {
                    "group_id": group_id,
                    "group_name": summary.get("groupName", ""),
                    "picture_url": summary.get("pictureUrl", ""),
                }
                self._group_info_cache[group_id] = {"data": data, "cached_at": time.time()}
                return data
        except Exception:
            pass

        return cached.get("data", {}) if cached else {}

    async def get_member_count(self, group_id: str) -> int | None:
        if not self._sender:
            return None
        try:
            count = await self._sender.get_group_member_count(group_id)
            return count
        except Exception:
            return None

    def _cache_profile(self, user_id: str, data: dict) -> None:
        self._profile_cache[user_id] = {"data": data, "cached_at": time.time()}
        if len(self._profile_cache) > 1000:
            oldest_keys = sorted(self._profile_cache.keys())[:500]
            for k in oldest_keys:
                del self._profile_cache[k]

    async def _lookup_friends_info(self, user_id: str) -> dict | None:
        return None

    async def pre_connect(self) -> dict:
        token, _ = await self._resolve_token_and_secret()
        if not token:
            return {"status": "error", "message": "Missing channel_access_token"}

        probe_result = await probe_line_bot(token)
        if probe_result.get("status") == "error":
            return {"status": "error", "message": probe_result.get("message", "Probe failed")}
        return probe_result

    async def agent_prompt(self) -> str | None:
        prompts = []
        if self._agent_prompt:
            prompts.append(self._agent_prompt)
        else:
            prompts.extend(
                [
                    "你正在通过 LINE 与用户对话。",
                    "用户可以发送文本、图片、视频、音频、文件、位置和贴纸。",
                ]
            )
        prompts.extend(
            [
                "你可以通过 Flex Message 发送丰富的卡片内容，包括气泡卡片和轮播卡片。",
                "LINE 消息支持 Quick Reply（最多 13 个选项）、Confirm 模板和 Buttons 模板。",
                "你发送的 Markdown 文本会自动转换为 LINE 兼容的装饰文本（粗体、斜体、删除线）。",
                "使用 [[card:receipt:{...}]] 指令发送收据卡片，使用 [[card:event:{...}]] 发送事件卡片。",
                "文本消息限制为 5000 字符，单次最多发送 5 条消息。",
                "群组消息中，当 Bot 被 @提及 时 `is_bot_mentioned` 为 true。",
            ]
        )
        hints = self._message_tool_hints()
        if hints:
            prompts.append(hints)
        return "\n".join(prompts)

    def _message_tool_hints(self) -> str:
        return (
            "## 富消息工具提示\n"
            "你可以使用 `[[directive]]` 指令语法直接构建 LINE 富消息:\n"
            "- `[[quick_replies: 选项1, 选项2, ...]]` — 快速回复按钮（最多13个）\n"
            "- `[[confirm: 问题 | 是按钮文字 | 否按钮文字]]` — 确认模板\n"
            "- `[[buttons: 标题 | 描述 | 按钮1:数据, 按钮2:数据]]` — 按钮模板\n"
            "- `[[location: 标题 | 地址 | 纬度 | 经度]]` — 位置消息\n"
            "- `[[card:receipt|agenda|event|media|apple_tv|device_control|info:{...}]]` — Flex 卡片\n"
            "- 附加信息使用 `[[extra: 内容]]`\n"
        )

    async def heartbeat(self) -> bool:
        if self._status != ChannelStatus.CONNECTED or not self._sender:
            return False
        try:
            info = await self._sender.get_bot_info()
            return info is not None
        except Exception:
            return False

    async def list_peers(self, limit: int = 50) -> list[dict]:
        peers: list[dict] = []
        for uid in list(self._dm_allow_from)[:limit]:
            try:
                info = await self.get_user_info(uid)
                if info:
                    peers.append({"type": "user", "id": uid, "name": info.get("display_name", uid)})
            except Exception:
                pass

        for gid in list(self._groups_config.keys())[:limit]:
            peers.append({"type": "group", "id": gid, "enabled": self._groups_config[gid].get("enabled", True)})

        return peers

    def build_channel_summary(self) -> dict:
        return {
            "channel": "line",
            "status": self._status.value if hasattr(self._status, "value") else str(self._status),
            "dm_policy": self.dm_policy,
            "group_policy": self.group_policy,
            "allow_from_count": len(self._dm_allow_from),
            "group_config_count": len(self._groups_config),
            "pending_pairings": len(self._dm_pending_pairing),
            "seen_webhook_ids": len(self._seen_webhook_ids),
            "seen_message_ids": len(self._seen_message_ids),
            "sent_message_cache_size": len(self._sent_message_cache),
            "last_error": self._last_error,
            "reconnect_attempts": self._reconnect_attempts,
            "bot_name": self._bot_info.get("display_name", ""),
        }

    def collect_status_issues(self) -> list[dict]:
        issues: list[dict] = []
        if self._status != ChannelStatus.CONNECTED:
            issues.append({"severity": "error", "message": f"Channel not connected: {self._status}"})
        if self._last_error:
            issues.append({"severity": "warning", "message": f"Last error: {self._last_error}"})
        if self.dm_policy == "allowlist" and len(self._dm_allow_from) == 0:
            issues.append({"severity": "warning", "message": "DM allowlist is empty"})
        if self.group_policy == "allowlist" and len(self._groups_config) == 0:
            issues.append({"severity": "warning", "message": "Group allowlist is empty"})
        return issues

    def collect_audit_findings(self) -> list[dict]:
        findings: list[dict] = []
        findings.append(
            {
                "check": "dm_policy",
                "value": self.dm_policy,
                "status": "ok" if self.dm_policy == "open" or len(self._dm_allow_from) > 0 else "warn",
                "detail": f"DM policy: {self.dm_policy}, allowlist size: {len(self._dm_allow_from)}",
            }
        )
        findings.append(
            {
                "check": "group_policy",
                "value": self.group_policy,
                "status": "ok" if self.group_policy == "open" or len(self._groups_config) > 0 else "warn",
                "detail": f"Group policy: {self.group_policy}, configured groups: {len(self._groups_config)}",
            }
        )
        findings.append(
            {
                "check": "token_configured",
                "status": "ok" if self._cached_token else "warn",
                "detail": "Channel access token is configured"
                if self._cached_token
                else "Channel access token missing",
            }
        )
        findings.append(
            {
                "check": "secret_configured",
                "status": "ok" if self._cached_secret else "warn",
                "detail": "Channel secret is configured" if self._cached_secret else "Channel secret missing",
            }
        )
        findings.append(
            {
                "check": "webhook_path",
                "value": self.webhook_path,
                "status": "ok",
                "detail": f"Webhook path: {self.webhook_path}",
            }
        )
        return findings

    async def _auto_disable_graduated(self, reason: str) -> None:
        from yuxi.channels.adapters.line.send import _BASE_BACKOFF, _MAX_RETRIES

        self._reconnect_attempts += 1
        if self._reconnect_attempts <= _MAX_RETRIES:
            wait = _BASE_BACKOFF * (2 ** (self._reconnect_attempts - 1))
            logger.warning(
                f"[LINE] auth/disable retry {self._reconnect_attempts}/{_MAX_RETRIES}, "
                f"waiting {wait:.1f}s before reconnect (reason: {reason})"
            )
            await asyncio.sleep(wait)
            try:
                await self.connect()
                self._reconnect_attempts = 0
                logger.info("[LINE] reconnected after graduated retry")
                return
            except Exception as e:
                logger.warning(f"[LINE] reconnect attempt {self._reconnect_attempts} failed: {e}")

        logger.error(f"[LINE] all {_MAX_RETRIES} reconnect attempts exhausted, disabling channel")
        await self._auto_disable(reason)

    async def before_deliver_payload(self, messages: list[dict]) -> list[dict]:
        return [msg for msg in messages if msg is not None]

    async def reload(self) -> None:
        logger.info("[LINE] reloading configuration")
        if self._sender:
            try:
                await self._sender.__aexit__()
            except Exception:
                pass
            self._sender = None
        token, _ = await self._resolve_token_and_secret()
        if token:
            self._cached_token = token
        self._seen_webhook_ids.clear()
        self._seen_message_ids.clear()
        self._reconnect_attempts = 0
        if self._status == ChannelStatus.CONNECTED:
            await self.connect()


def _gen_pairing_code(length: int = 6) -> str:
    import secrets
    import string

    return "".join(secrets.choice(string.digits) for _ in range(length))


def _bot_mentioned(content: str, self_user_id: str | None) -> bool:
    if not content or not self_user_id:
        return False
    return self_user_id.lower() in content.lower()


def _is_dm_chat(chat_id: str) -> bool:
    return chat_id.startswith("user_")


def _is_group_chat(chat_id: str) -> bool:
    return chat_id.startswith("group_") or chat_id.startswith("room_")


def _is_private_hostname(hostname: str) -> bool:
    if not hostname:
        return True
    private_suffixes = (
        ".local",
        ".localhost",
        ".internal",
        ".intranet",
        ".corp",
        ".lan",
        ".home",
        ".test",
    )
    hostname_lower = hostname.lower()
    if hostname_lower in ("localhost", "127.0.0.1", "::1", "0.0.0.0"):
        return True
    if hostname_lower.startswith("10.") or hostname_lower.startswith("192.168."):
        return True
    if hostname_lower.startswith("172."):
        parts = hostname_lower.split(".")
        try:
            second = int(parts[1])
            if 16 <= second <= 31:
                return True
        except (IndexError, ValueError):
            pass
    if hostname_lower.startswith("169.254."):
        return True
    if hostname_lower.startswith("fc") or hostname_lower.startswith("fd"):
        return True
    if any(hostname_lower.endswith(suffix) for suffix in private_suffixes):
        return True
    return False


def _resolve_mentions(content: str, self_user_id: str | None, raw_event: dict | None = None) -> MentionsInfo:
    if not content and not raw_event:
        return MentionsInfo()

    mentioned_ids: list[str] = []
    is_bot_mentioned = False

    if raw_event:
        message_obj = raw_event.get("message", {})
        mention_data = message_obj.get("mention")
        if isinstance(mention_data, dict):
            native_mentionees = mention_data.get("mentionees", [])
            for m in native_mentionees:
                if isinstance(m, dict):
                    uid = m.get("userId", "")
                    if uid and uid not in mentioned_ids:
                        mentioned_ids.append(uid)
                    if uid.lower() == (self_user_id or "").lower():
                        is_bot_mentioned = True

    if content:
        _mention_pattern = re.compile(r"@(U[a-f0-9]{32})", re.IGNORECASE)
        for mention_id in _mention_pattern.findall(content):
            if mention_id not in mentioned_ids:
                mentioned_ids.append(mention_id)
            if mention_id.lower() == (self_user_id or "").lower():
                is_bot_mentioned = True

        if not is_bot_mentioned and self_user_id:
            _pattern_mention = re.compile(
                rf"@\s*{re.escape(self_user_id)}\b|@bot\b|@\s*bot\b",
                re.IGNORECASE,
            )
            if _pattern_mention.search(content):
                is_bot_mentioned = True

    return MentionsInfo(
        mentioned_user_ids=mentioned_ids,
        is_bot_mentioned=is_bot_mentioned,
        raw_text=content,
    )


def _validate_target_id(target_id: str) -> bool:
    return bool(re.match(r"^[UCR][a-f0-9]{32}$|^line:", target_id, re.IGNORECASE))