astrbotmcp 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

astrbot_mcp/tools/{message_tools.py → message/webchat.py}

@@ -1,380 +1,54 @@
 from __future__ import annotations
 
-import asyncio
 import os
-import textwrap
-from typing import Any, Dict, List, Literal, Optional, Tuple, TypedDict
-
-from ..astrbot_client import AstrBotClient
-from .helpers import (
-    _as_file_uri,
-    _attachment_download_url,
-    _astrbot_connect_hint,
-    _direct_media_mode,
-    _httpx_error_detail,
-    _resolve_local_file_path,
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Literal, Optional
+
+from ...astrbot_client import AstrBotClient
+from ..helpers import _httpx_error_detail, _resolve_local_file_path
+from ..types import MessagePart
+from .cache import (
+    _LAST_SAVED_MESSAGE_ID_BY_SESSION,
+    _LAST_SAVED_MESSAGE_ID_LOCK,
+    _LAST_USER_MESSAGE_ID_BY_SESSION,
+    _LAST_USER_MESSAGE_ID_LOCK,
+    _SESSION_CACHE,
+    _SESSION_CACHE_LOCK,
+    _last_saved_key,
+    _session_cache_key,
 )
-from .types import MessagePart
+from .direct import send_platform_message_direct
+from .quote import _resolve_webchat_quotes
+from .utils import _extract_plain_text_from_history_item, _normalize_history_message_id
 
 
-_SESSION_CACHE_LOCK = asyncio.Lock()
-_SESSION_CACHE: Dict[Tuple[str, str, str], str] = {}
-
-_LAST_SAVED_MESSAGE_ID_LOCK = asyncio.Lock()
-_LAST_SAVED_MESSAGE_ID_BY_SESSION: Dict[Tuple[str, str, str], str] = {}
-
-
-def _session_cache_key(client: AstrBotClient, platform_id: str) -> Tuple[str, str, str]:
-    return (client.base_url, client.settings.username or "", platform_id)
-
-
-def _last_saved_key(client: AstrBotClient, session_id: str) -> Tuple[str, str, str]:
-    return (client.base_url, client.settings.username or "", session_id)
-
-
-def _extract_plain_text_from_history_item(item: Dict[str, Any]) -> str:
-    content = item.get("content") or {}
-    if not isinstance(content, dict):
-        return str(content)
-    message = content.get("message") or []
-    if not isinstance(message, list):
-        return str(message)
-
-    chunks: List[str] = []
-    for part in message:
-        if not isinstance(part, dict):
-            continue
-        p_type = part.get("type")
-        if p_type == "plain":
-            txt = part.get("text")
-            if isinstance(txt, str) and txt:
-                chunks.append(txt)
-        elif p_type in ("image", "file", "record", "video"):
-            name = part.get("filename") or part.get("attachment_id") or ""
-            if name:
-                chunks.append(f"[{p_type}:{name}]")
-            else:
-                chunks.append(f"[{p_type}]")
-        else:
-            if p_type:
-                chunks.append(f"[{p_type}]")
-    return "".join(chunks).strip()
-
-
-def _format_quote_block(*, message_id: str, sender: str, text: str) -> str:
-    sender = (sender or "unknown").strip() or "unknown"
-    text = (text or "").strip()
-    if not text:
-        text = "<empty>"
-    text = textwrap.shorten(text, width=800, placeholder="…")
-    return f"[引用消息 {message_id} | {sender}] {text}\n"
-
-
-async def _resolve_webchat_quotes(
-    client: AstrBotClient, *, session_id: str, reply_ids: List[str]
-) -> Tuple[str, Dict[str, Any]]:
-    """
-    Resolve WebChat `message_saved.id` -> quoted text by calling /api/chat/get_session.
-    Best-effort: returns a quote prefix text and debug info.
-    """
-    cleaned: List[str] = []
-    for rid in reply_ids:
-        s = str(rid).strip()
-        if s:
-            cleaned.append(s)
-    if not cleaned:
-        return "", {"resolved": {}, "missing": []}
-
+async def _get_astrbot_log_tail(
+    client: AstrBotClient, *, limit: int = 120
+) -> Dict[str, Any] | None:
     try:
-        resp = await client.get_platform_session(session_id=session_id)
+        hist = await client.get_log_history()
     except Exception as e:
-        return "", {"error": str(e), "resolved": {}, "missing": cleaned}
-
-    if resp.get("status") != "ok":
-        return "", {"status": resp.get("status"), "message": resp.get("message"), "raw": resp}
-
-    data = resp.get("data") or {}
-    history = data.get("history") or []
-    if not isinstance(history, list):
-        return "", {"resolved": {}, "missing": cleaned, "raw_history_type": str(type(history))}
-
-    index: Dict[str, Dict[str, Any]] = {}
-    for item in history:
-        if not isinstance(item, dict):
-            continue
-        mid = item.get("id")
-        if mid is None:
-            continue
-        index[str(mid)] = item
-
-    resolved: Dict[str, str] = {}
-    missing: List[str] = []
-    blocks: List[str] = []
-    for rid in cleaned:
-        item = index.get(str(rid))
-        if not item:
-            missing.append(rid)
-            blocks.append(
-                _format_quote_block(
-                    message_id=str(rid),
-                    sender="missing",
-                    text="<not found in /api/chat/get_session history>",
-                )
-            )
-            continue
-        sender = (
-            item.get("sender_name")
-            or item.get("sender_id")
-            or "unknown"
-        )
-        txt = _extract_plain_text_from_history_item(item)
-        block = _format_quote_block(message_id=str(rid), sender=str(sender), text=txt)
-        resolved[str(rid)] = block
-        blocks.append(block)
-
-    return "".join(blocks), {"resolved": resolved, "missing": missing}
-
-
-async def send_platform_message_direct(
-    platform_id: str,
-    target_id: str,
-    message_chain: Optional[List[MessagePart]] = None,
-    message: Optional[str] = None,
-    images: Optional[List[str]] = None,
-    files: Optional[List[str]] = None,
-    videos: Optional[List[str]] = None,
-    records: Optional[List[str]] = None,
-    message_type: Literal["GroupMessage", "FriendMessage"] = "GroupMessage",
-) -> Dict[str, Any]:
-    """
-    NOTE:
-      - If you provide `target_id`, this tool will call AstrBot dashboard API `/api/platform/send_message`
-        (bypass LLM) to send to a real group/user.
-      - If you do NOT provide `target_id`, this tool uses AstrBot WebChat `/api/chat/send` (LLM required),
-        and will always create/reuse a `webchat` session even if you pass another platform_id.
-    Directly send a message chain to a platform group/user (bypass LLM).
-
-    This calls AstrBot dashboard endpoint: POST /api/platform/send_message
-
-    Notes:
-      - This is for sending to a real platform target (group/user), not WebChat.
-      - Media parts:
-        - If `file_path` is a local path, this tool will upload it to AstrBot first, then send it as an AstrBot-hosted URL.
-        - If `file_path`/`url` is an http(s) URL, it will be forwarded as-is.
-    """
-    client = AstrBotClient.from_env()
-    onebot_like = platform_id.strip().lower() in {
-        "napcat",
-        "onebot",
-        "cqhttp",
-        "gocqhttp",
-        "llonebot",
-    }
-
-    if message_chain is None:
-        message_chain = []
-        if message:
-            message_chain.append({"type": "plain", "text": message})
-        for src in images or []:
-            message_chain.append({"type": "image", "file_path": src})
-        for src in files or []:
-            message_chain.append({"type": "file", "file_path": src})
-        for src in records or []:
-            message_chain.append({"type": "record", "file_path": src})
-        for src in videos or []:
-            message_chain.append({"type": "video", "file_path": src})
-
-    async def build_chain(mode: str) -> tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
-        normalized_chain: List[Dict[str, Any]] = []
-        uploaded_attachments: List[Dict[str, Any]] = []
-
-        for part in message_chain or []:
-            p_type = part.get("type")
-            if p_type in ("image", "file", "record", "video"):
-                file_path = part.get("file_path")
-                url = part.get("url")
-                file_name = part.get("file_name")
-                mime_type = part.get("mime_type")
-                src = url or file_path
-                if not src:
-                    continue
-
-                normalized = dict(part)
-                if not isinstance(src, str):
-                    raise ValueError(f"Invalid media source (expected str): {src!r}")
-
-                if src.startswith(("http://", "https://")):
-                    normalized["file_path"] = src
-                    if onebot_like:
-                        normalized.setdefault("file", src)
-                    normalized.pop("url", None)
-                    normalized_chain.append(normalized)
-                    continue
-
-                try:
-                    local_path = _resolve_local_file_path(client, src)
-                except ValueError as e:
-                    raise ValueError(str(e)) from e
-                except FileNotFoundError as e:
-                    raise FileNotFoundError(f"Local file_path does not exist: {src!r}") from e
-
-                if mode == "local":
-                    normalized["file_path"] = local_path
-                    normalized.pop("url", None)
-                    if onebot_like:
-                        uri = _as_file_uri(local_path)
-                        normalized.setdefault("file", uri or local_path)
-                    normalized_chain.append(normalized)
-                    continue
-
-                if mode != "upload":
-                    raise ValueError(f"Unknown direct media mode: {mode!r}")
-
-                if not file_name:
-                    file_name = os.path.basename(local_path) or None
-
-                attach_resp = await client.post_attachment_file(
-                    local_path,
-                    file_name=file_name,
-                    mime_type=mime_type,
-                )
-
-                if attach_resp.get("status") != "ok":
-                    raise RuntimeError(attach_resp.get("message") or "Attachment upload failed")
-
-                attach_data = attach_resp.get("data") or {}
-                attachment_id = attach_data.get("attachment_id")
-                if not attachment_id:
-                    raise RuntimeError(
-                        "Attachment upload succeeded but attachment_id is missing"
-                    )
-
-                download_url = _attachment_download_url(client, str(attachment_id))
-                normalized["file_path"] = download_url
-                if onebot_like:
-                    normalized.setdefault("file", download_url)
-                normalized.pop("url", None)
-                normalized.pop("file_name", None)
-                normalized.pop("mime_type", None)
-                uploaded_attachments.append(attach_data)
-                normalized_chain.append(normalized)
-            else:
-                normalized_chain.append(dict(part))
-
-        return normalized_chain, uploaded_attachments
-
-    # Prefer local paths (more compatible with Napcat / Windows), but keep an upload fallback.
-    try:
-        mode = _direct_media_mode(client)
-    except ValueError as e:
         return {
             "status": "error",
-            "message": str(e),
-            "platform_id": platform_id,
-            "session_id": str(target_id),
-            "message_type": message_type,
+            "message": f"AstrBot API error: {getattr(getattr(e, 'response', None), 'status_code', None) or 'Unknown'}",
+            "detail": _httpx_error_detail(e),
         }
-    modes_to_try = ["local", "upload"] if mode == "auto" else [mode]
-    last_error: Dict[str, Any] | None = None
-
-    for attempt_mode in modes_to_try:
-        try:
-            normalized_chain, uploaded_attachments = await build_chain(attempt_mode)
-        except FileNotFoundError as e:
-            return {
-                "status": "error",
-                "message": str(e),
-                "platform_id": platform_id,
-                "session_id": str(target_id),
-                "message_type": message_type,
-                "hint": "If you passed a relative path, set ASTRBOTMCP_FILE_ROOT (or run the server in the correct working directory).",
-            }
-        except ValueError as e:
-            return {
-                "status": "error",
-                "message": str(e),
-                "platform_id": platform_id,
-                "session_id": str(target_id),
-                "message_type": message_type,
-                "hint": "Set ASTRBOTMCP_FILE_ROOT to control how relative paths are resolved.",
-            }
-        except Exception as e:
-            return {
-                "status": "error",
-                "message": str(e),
-                "platform_id": platform_id,
-                "session_id": str(target_id),
-                "message_type": message_type,
-                "attempt_mode": attempt_mode,
-            }
-
-        if not normalized_chain:
-            return {
-                "status": "error",
-                "message": "message_chain did not produce any valid message parts",
-                "platform_id": platform_id,
-                "session_id": str(target_id),
-                "message_type": message_type,
-            }
-
-        try:
-            direct_resp = await client.send_platform_message_direct(
-                platform_id=platform_id,
-                message_type=message_type,
-                session_id=str(target_id),
-                message_chain=normalized_chain,
-            )
-        except Exception as e:
-            status_code = getattr(getattr(e, "response", None), "status_code", None)
-            hint = "Ensure AstrBot includes /api/platform/send_message and you are authenticated."
-            if status_code in (404, 405):
-                hint = (
-                    "Your AstrBot may not expose /api/platform/send_message (some versions only provide "
-                    "/api/platform/stats and /api/platform/webhook). Upgrade AstrBot or add an HTTP route for sending."
-                )
-            return {
-                "status": "error",
-                "message": (
-                    f"AstrBot API error: HTTP {status_code}"
-                    if status_code is not None
-                    else f"AstrBot API error: {e}"
-                ),
-                "platform_id": platform_id,
-                "session_id": str(target_id),
-                "message_type": message_type,
-                "attempt_mode": attempt_mode,
-                "detail": _httpx_error_detail(e),
-                "hint": hint,
-            }
-
-        status = direct_resp.get("status")
-        if status == "ok":
-            data = direct_resp.get("data") or {}
-            return {
-                "status": "ok",
-                "platform_id": data.get("platform_id", platform_id),
-                "session_id": data.get("session_id", str(target_id)),
-                "message_type": data.get("message_type", message_type),
-                "attempt_mode": attempt_mode,
-                "uploaded_attachments": uploaded_attachments,
-            }
-
-        last_error = {
-            "status": status,
-            "platform_id": platform_id,
-            "session_id": str(target_id),
-            "message_type": message_type,
-            "attempt_mode": attempt_mode,
-            "message": direct_resp.get("message"),
-            "raw": direct_resp,
+    if hist.get("status") != "ok":
+        return {
+            "status": hist.get("status"),
+            "message": hist.get("message"),
+            "raw": hist,
         }
-
-    return last_error or {
-        "status": "error",
-        "message": "Failed to send message",
-        "platform_id": platform_id,
-        "session_id": str(target_id),
-        "message_type": message_type,
+    logs = (hist.get("data") or {}).get("logs", [])
+    if not isinstance(logs, list):
+        return {
+            "status": "error",
+            "message": "Unexpected /api/log-history response shape (logs is not a list).",
+            "raw": hist,
+        }
+    return {
+        "status": "ok",
+        "logs": logs[-max(1, int(limit)) :],
     }
 
 
@@ -394,6 +68,7 @@ async def send_platform_message(
     new_session: bool = False,
     reply_to_message_id: Optional[str] = None,
     reply_to_last_saved_message: bool = False,
+    reply_to_last_user_message: bool = False,
     selected_provider: Optional[str] = None,
     selected_model: Optional[str] = None,
     enable_streaming: bool = True,
@@ -433,6 +108,7 @@ async def send_platform_message(
     mode = "webchat"
     session_platform_id = "webchat"
     routing_debug: Dict[str, Any] = {}
+    send_started_at = datetime.now(timezone.utc)
 
     if message_chain is None:
         message_chain = []
@@ -597,6 +273,14 @@ async def send_platform_message(
     else:
         routing_debug["skipped"] = "No ASTRBOT_USERNAME configured; cannot mirror dashboard session routing."
 
+    if reply_to_last_user_message and not reply_to_message_id:
+        async with _LAST_USER_MESSAGE_ID_LOCK:
+            reply_to_message_id = _LAST_USER_MESSAGE_ID_BY_SESSION.get(
+                _last_saved_key(client, used_session_id)
+            )
+
+    # reply_to_last_saved_message historically points to the last saved bot message (message_saved.id).
+    # With user_message_saved supported, callers can prefer last_user_message_id from the response.
     if reply_to_last_saved_message and not reply_to_message_id:
         async with _LAST_SAVED_MESSAGE_ID_LOCK:
             reply_to_message_id = _LAST_SAVED_MESSAGE_ID_BY_SESSION.get(
@@ -604,29 +288,28 @@ async def send_platform_message(
             )
 
     # 2. 把 message_chain 转成 AstrBot chat/send 需要的 message_parts
-    reply_ids: List[str] = []
-    if reply_to_message_id:
-        reply_ids.append(str(reply_to_message_id))
-
+    explicit_reply_present = False
     for part in message_chain:
         if not isinstance(part, dict):
             continue
         if part.get("type") in ("reply", "quote", "reference"):
             msg_id = part.get("message_id") or part.get("id")
-            if msg_id:
-                reply_ids.append(str(msg_id))
-
-    quote_prefix = ""
-    quote_debug: Dict[str, Any] | None = None
-    if reply_ids:
-        quote_prefix, quote_debug = await _resolve_webchat_quotes(
-            client, session_id=used_session_id, reply_ids=reply_ids
-        )
+            if msg_id is not None and str(msg_id).strip():
+                explicit_reply_present = True
+                break
 
     message_parts: List[Dict[str, Any]] = []
-    if quote_prefix:
-        message_parts.append({"type": "plain", "text": quote_prefix})
+    reply_ids: List[str] = []
+    if reply_to_message_id and not explicit_reply_present:
+        message_parts.append(
+            {
+                "type": "reply",
+                "message_id": _normalize_history_message_id(reply_to_message_id),
+            }
+        )
+        reply_ids.append(str(reply_to_message_id))
 
+    quote_debug: Dict[str, Any] | None = None
     uploaded_attachments: List[Dict[str, Any]] = []
 
     for part in message_chain:
@@ -636,7 +319,16 @@ async def send_platform_message(
             text = part.get("text", "")
             message_parts.append({"type": "plain", "text": text})
         elif p_type in ("reply", "quote", "reference"):
-            continue
+            msg_id = part.get("message_id") or part.get("id")
+            if msg_id is None:
+                continue
+            msg_id_str = str(msg_id).strip()
+            if not msg_id_str:
+                continue
+            message_parts.append(
+                {"type": "reply", "message_id": _normalize_history_message_id(msg_id)}
+            )
+            reply_ids.append(msg_id_str)
         elif p_type in ("image", "file", "record", "video"):
             file_path = part.get("file_path")
             url = part.get("url")
@@ -734,6 +426,14 @@ async def send_platform_message(
             # 忽略未知类型
             continue
 
+    if reply_ids:
+        try:
+            _ignored, quote_debug = await _resolve_webchat_quotes(
+                client, session_id=used_session_id, reply_ids=reply_ids
+            )
+        except Exception as e:
+            quote_debug = {"error": str(e), "resolved": {}, "missing": reply_ids}
+
     if not message_parts:
         return {
             "status": "error",
@@ -783,6 +483,7 @@ async def send_platform_message(
             "selected_model": effective_model,
             "request_message_parts": message_parts,
             "detail": _httpx_error_detail(e),
+            "astrbot_logs_tail": await _get_astrbot_log_tail(client),
             "hint": (
                 "If you see 'has no provider supported' in AstrBot logs, "
                 "set selected_provider/selected_model (or env ASTRBOT_DEFAULT_PROVIDER/ASTRBOT_DEFAULT_MODEL)."
@@ -794,6 +495,7 @@ async def send_platform_message(
     # 简单聚合文本回复（仅供参考，保留原始事件）
     reply_text_chunks: List[str] = []
     saved_message_ids: List[str] = []
+    user_message_ids: List[str] = []
     if not events:
         return {
             "status": "error",
@@ -805,12 +507,66 @@ async def send_platform_message(
             "selected_provider": effective_provider,
             "selected_model": effective_model,
             "request_message_parts": message_parts,
+            "astrbot_logs_tail": await _get_astrbot_log_tail(client),
             "hint": "Check AstrBot logs for the root cause (often provider/model config).",
             "quote_debug": quote_debug,
             "routing_debug": routing_debug,
         }
 
+    # If we only got bookkeeping events (e.g., user_message_saved) but no response stream at all,
+    # treat it as an error while still returning useful ids.
+    response_types = {
+        "plain",
+        "complete",
+        "image",
+        "record",
+        "file",
+        "message_saved",
+        "end",
+        "break",
+        "raw",
+    }
+    has_response = any(ev.get("type") in response_types for ev in events if isinstance(ev, dict))
+    if not has_response:
+        user_ids = []
+        for ev in events:
+            if not isinstance(ev, dict):
+                continue
+            if ev.get("type") == "user_message_saved":
+                data = ev.get("data") or {}
+                mid = data.get("id")
+                if mid is not None:
+                    user_ids.append(str(mid))
+        # Some plugins reply by side effects (e.g., sending messages via adapters) and may only
+        # emit bookkeeping events on the WebChat SSE stream. Treat as ok but include a warning.
+        return {
+            "status": "ok",
+            "warning": "No reply events were observed on the /api/chat/send SSE stream; check AstrBot logs if you expected an LLM reply.",
+            "mode": mode,
+            "platform_id": session_platform_id,
+            "requested_platform_id": platform_id,
+            "session_id": used_session_id,
+            "selected_provider": effective_provider,
+            "selected_model": effective_model,
+            "request_message_parts": message_parts,
+            "user_message_ids": user_ids,
+            "last_user_message_id": (user_ids[-1] if user_ids else None),
+            "quote_debug": quote_debug,
+            "routing_debug": routing_debug,
+            "reply_events": events,
+            "astrbot_logs_tail": await _get_astrbot_log_tail(client),
+        }
+
     for ev in events:
+        if ev.get("type") == "user_message_saved":
+            data = ev.get("data") or {}
+            saved_id = data.get("id")
+            if saved_id is not None:
+                user_message_ids.append(str(saved_id))
+                async with _LAST_USER_MESSAGE_ID_LOCK:
+                    _LAST_USER_MESSAGE_ID_BY_SESSION[_last_saved_key(client, used_session_id)] = str(
+                        saved_id
+                    )
         if ev.get("type") == "message_saved":
             data = ev.get("data") or {}
             saved_id = data.get("id")
@@ -821,9 +577,77 @@ async def send_platform_message(
             if isinstance(data, str):
                 reply_text_chunks.append(data)
 
+    # Fallback: some AstrBot versions do not emit `user_message_saved`.
+    # Try to infer the latest user message id by fetching /api/chat/get_session and scanning history.
+    if not user_message_ids:
+        match_hint = None
+        for part in message_parts:
+            if not isinstance(part, dict):
+                continue
+            if part.get("type") == "plain":
+                txt = part.get("text")
+                if isinstance(txt, str) and txt.strip():
+                    match_hint = txt.strip()
+                    break
+
+        try:
+            sess = await client.get_platform_session(session_id=used_session_id)
+            if sess.get("status") == "ok":
+                history = (sess.get("data") or {}).get("history") or []
+                if isinstance(history, list):
+                    expected_sender = (client.settings.username or "").strip() or None
+
+                    def is_recent_user_record(item: Dict[str, Any]) -> bool:
+                        if not isinstance(item, dict):
+                            return False
+                        content = item.get("content") or {}
+                        if not isinstance(content, dict) or content.get("type") != "user":
+                            return False
+                        if expected_sender and item.get("sender_name") != expected_sender:
+                            return False
+                        if match_hint:
+                            extracted = _extract_plain_text_from_history_item(item)
+                            if match_hint[:32] not in extracted:
+                                return False
+                        created_at = item.get("created_at")
+                        if isinstance(created_at, str) and created_at:
+                            try:
+                                # e.g. 2025-12-18T21:47:07.684801+08:00
+                                dt = datetime.fromisoformat(created_at)
+                                if dt.tzinfo is None:
+                                    dt = dt.replace(tzinfo=timezone.utc)
+                                # accept a small clock skew window
+                                return dt.astimezone(timezone.utc) >= send_started_at.replace(
+                                    microsecond=0
+                                ) - timedelta(seconds=5)
+                            except Exception:
+                                pass
+                        return True
+
+                    # Look from newest to oldest for a likely match.
+                    for item in reversed(history):
+                        if not isinstance(item, dict):
+                            continue
+                        if not is_recent_user_record(item):
+                            continue
+                        mid = item.get("id")
+                        if mid is None:
+                            continue
+                        user_message_ids.append(str(mid))
+                        async with _LAST_USER_MESSAGE_ID_LOCK:
+                            _LAST_USER_MESSAGE_ID_BY_SESSION[_last_saved_key(client, used_session_id)] = str(
+                                mid
+                            )
+                        break
+        except Exception as e:
+            routing_debug["user_id_fallback_exception"] = str(e)
+
     last_saved_message_id: str | None = (
         saved_message_ids[-1] if saved_message_ids else None
     )
+    last_user_message_id: str | None = (
+        user_message_ids[-1] if user_message_ids else None
+    )
     if last_saved_message_id:
         async with _LAST_SAVED_MESSAGE_ID_LOCK:
             _LAST_SAVED_MESSAGE_ID_BY_SESSION[_last_saved_key(client, used_session_id)] = (
@@ -844,6 +668,8 @@ async def send_platform_message(
         "uploaded_attachments": uploaded_attachments,
         "reply_events": events,
         "reply_text": "".join(reply_text_chunks),
+        "user_message_ids": user_message_ids,
+        "last_user_message_id": last_user_message_id,
         "saved_message_ids": saved_message_ids,
         "last_saved_message_id": last_saved_message_id,
         "quote_debug": quote_debug,