fix(qq): isolate conversation sessions and preserve reply routes (#7169)

Author: hongxicheng

src/qwenpaw/app/channels/qq/cards/tool_guard.py

@@ -473,7 +473,7 @@ async def _send_resolved_message(
     guild_id = str(session_ctx.get("gid") or "")
     msg_id = str(session_ctx.get("mid") or "")
 
-    if not sender_id and not group_openid and not channel_id:
+    if not any((sender_id, group_openid, channel_id, guild_id)):
         logger.warning("qq resolved message: no target to send to")
         return
 
@@ -525,7 +525,9 @@ def _enqueue_approval_command(
     session_id = str(session_ctx.get("sid") or "")
     message_type = str(session_ctx.get("mt") or "c2c")
     group_openid = str(session_ctx.get("goid") or "")
-    is_group = message_type == "group"
+    channel_id = str(session_ctx.get("cid") or "")
+    guild_id = str(session_ctx.get("gid") or "")
+    is_group = message_type in ("group", "guild")
 
     command_text = f"/approval {action} {request_id}"
     payload = {
@@ -540,6 +542,8 @@ def _enqueue_approval_command(
             "message_type": message_type,
             "sender_id": sender_id,
             "group_openid": group_openid,
+            "channel_id": channel_id,
+            "guild_id": guild_id,
             "is_group": is_group,
             "from_card_action": True,
         },

src/qwenpaw/app/channels/qq/channel.py

@@ -857,29 +857,122 @@ def _resolve_send_path(
         guild_id: Optional[str] = None,
     ) -> tuple[str, bool, str]:
         """Return (api_path, use_msg_seq, seq_key)."""
-        if message_type == "dm" and guild_id:
+        if message_type == "dm":
+            if not guild_id:
+                raise ValueError("QQ guild DM route requires guild_id")
             return (
                 f"/dms/{guild_id}/messages",
                 False,
                 "",
             )
-        if message_type == "group" and group_openid:
+        if message_type == "group":
+            if not group_openid:
+                raise ValueError("QQ group route requires group_openid")
             return (
                 f"/v2/groups/{group_openid}/messages",
                 True,
                 "group",
             )
-        if message_type == "guild" and channel_id:
+        if message_type == "guild":
+            if not channel_id:
+                raise ValueError("QQ guild route requires channel_id")
             return (
                 f"/channels/{channel_id}/messages",
                 False,
                 "",
             )
-        # c2c or fallback
+        if message_type == "c2c":
+            if not sender_id:
+                raise ValueError("QQ C2C route requires user_openid")
+            return (
+                f"/v2/users/{sender_id}/messages",
+                True,
+                "c2c",
+            )
+        raise ValueError(f"Unsupported QQ message_type: {message_type}")
+
+    # ------------------------------------------------------------------
+    # Session / route helpers
+    # ------------------------------------------------------------------
+
+    def resolve_session_id(
+        self,
+        sender_id: str,
+        channel_meta: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """Return a session ID scoped to one QQ conversation."""
+        meta = channel_meta or {}
+        message_type = str(meta.get("message_type") or "c2c")
+        if message_type == "group":
+            group_openid = str(meta.get("group_openid") or "unknown")
+            return f"qq:group:{group_openid}"
+        if message_type == "guild":
+            channel_id = str(meta.get("channel_id") or "unknown")
+            return f"qq:guild:{channel_id}"
+        if message_type == "dm":
+            guild_id = str(meta.get("guild_id") or "unknown")
+            return f"qq:dm:{guild_id}"
+        return f"qq:c2c:{sender_id or 'unknown'}"
+
+    @staticmethod
+    def _route_meta_from_handle(to_handle: str) -> Dict[str, str]:
+        """Decode a QQ session ID or direct handle into routing metadata."""
+        handle = (to_handle or "").strip()
+        routes = (
+            ("qq:c2c:", "c2c", "sender_id"),
+            ("qq:group:", "group", "group_openid"),
+            ("qq:guild:", "guild", "channel_id"),
+            ("qq:dm:", "dm", "guild_id"),
+            ("qq:", "c2c", "sender_id"),
+            ("group:", "group", "group_openid"),
+            ("channel:", "guild", "channel_id"),
+        )
+        for prefix, message_type, target_key in routes:
+            if handle.startswith(prefix):
+                target = handle.removeprefix(prefix)
+                if target == "unknown":
+                    return {"message_type": message_type}
+                return {
+                    "message_type": message_type,
+                    target_key: target,
+                }
+        return {}
+
+    def _normalize_route_meta(
+        self,
+        to_handle: str,
+        meta: Optional[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        """Merge durable route data encoded in ``to_handle`` into metadata."""
+        route_meta = dict(meta or {})
+        encoded_route = self._route_meta_from_handle(to_handle)
+        if encoded_route:
+            route_meta.update(encoded_route)
+        else:
+            route_meta.setdefault("message_type", "c2c")
+            if to_handle:
+                route_meta.setdefault("sender_id", to_handle)
+        return route_meta
+
+    def to_handle_from_target(self, *, user_id: str, session_id: str) -> str:
+        """Return a durable QQ session handle for proactive sends."""
+        return session_id or f"qq:c2c:{user_id}"
+
+    def get_to_handle_from_request(self, request: Any) -> str:
+        """Return the request session ID so replies retain their route."""
+        session_id = getattr(request, "session_id", "") or ""
+        user_id = getattr(request, "user_id", "") or ""
+        return session_id or f"qq:c2c:{user_id}"
+
+    def get_on_reply_sent_args(
+        self,
+        request: Any,
+        to_handle: str,
+    ) -> tuple:
+        """Report the original QQ user and isolated session to the callback."""
         return (
-            f"/v2/users/{sender_id}/messages",
-            True,
-            "c2c",
+            getattr(request, "user_id", "") or "",
+            getattr(request, "session_id", "") or "",
         )
 
     async def _dispatch_text(
@@ -1093,12 +1186,12 @@ async def send(
         meta: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Send one text via QQ HTTP API.
-        Routes by meta or to_handle (group:/channel:/openid).
+        Routes by metadata or a conversation-scoped QQ session handle.
         """
         if not self.enabled or not text.strip():
             return
         text = text.strip()
-        meta = meta or {}
+        meta = self._normalize_route_meta(to_handle, meta)
         use_markdown = _as_bool(
             meta.get("markdown_enabled", self._markdown_enabled),
         )
@@ -1108,21 +1201,12 @@ async def send(
                 logger.info(
                     "qq send: stripped URL content for API compatibility",
                 )
-        message_type = meta.get("message_type")
+        message_type = str(meta.get("message_type") or "c2c")
         msg_id = meta.get("message_id")
         sender_id = meta.get("sender_id") or to_handle
         channel_id = meta.get("channel_id")
         group_openid = meta.get("group_openid")
         guild_id = meta.get("guild_id")
-        if message_type is None:
-            if to_handle.startswith("group:"):
-                message_type = "group"
-                group_openid = to_handle[6:]
-            elif to_handle.startswith("channel:"):
-                message_type = "guild"
-                channel_id = to_handle[8:]
-            else:
-                message_type = "c2c"
         try:
             token = await self._get_access_token_async()
         except Exception:
@@ -1326,14 +1410,19 @@ def build_agent_request_from_native(self, native_payload: Any) -> Any:
         if attachments:
             media_parts = self._parse_qq_attachments(attachments)
             content_parts = list(content_parts) + media_parts
-        session_id = self.resolve_session_id(sender_id, meta)
-        return self.build_agent_request_from_user_content(
+        session_id = payload.get("session_id") or self.resolve_session_id(
+            sender_id,
+            meta,
+        )
+        request = self.build_agent_request_from_user_content(
             channel_id=channel_id,
             sender_id=sender_id,
             session_id=session_id,
             content_parts=content_parts,
             channel_meta=meta,
         )
+        request.channel_meta = meta
+        return request
 
     # ------------------------------------------------------------------
     # Instant acknowledgment
@@ -1573,6 +1662,7 @@ async def on_event_message_completed(
         send_meta: Dict[str, Any],
     ) -> None:
         """Render card-flagged events via the card handler; else default."""
+        send_meta = self._normalize_route_meta(to_handle, send_meta)
         if await self._card_handler.try_send_card_for_event(
             to_handle,
             event,
@@ -2041,7 +2131,7 @@ async def send_content_parts(
 
         body = "\n".join(text_parts).strip() if text_parts else ""
 
-        meta = meta or {}
+        meta = self._normalize_route_meta(to_handle, meta)
         message_type = meta.get("message_type", "c2c")
         msg_id = meta.get("message_id")
 
@@ -2105,7 +2195,7 @@ async def send_media(
         if not self.enabled:
             return
 
-        meta = meta or {}
+        meta = self._normalize_route_meta(to_handle, meta)
         (
             message_type,
             sender_id,