Release alpha 0.6.6 autochess flow

wechat_adaptive_recorder.py

@@ -644,6 +644,7 @@ def edge_router_reply(
     *,
     legacy_router: Any,
     fast_ack_sender: Callable[[dict[str, Any], dict[str, Any]], bool] | None = None,
+    reply_sender: Callable[[dict[str, Any], dict[str, Any]], bool] | None = None,
 ) -> str:
     """Use the local edge if healthy, otherwise preserve the existing cloud route."""
 
@@ -688,6 +689,34 @@ def edge_router_reply(
             return legacy_router(event)
         return "JWeBot Error: Local edge unavailable"
     if response.get("status") == "reply":
+        texts = response.get("texts")
+        if (
+            isinstance(texts, list)
+            and len(texts) > 1
+            and all(isinstance(item, str) and 0 < len(item) <= 900 for item in texts)
+        ):
+            if reply_sender is None:
+                logging.warning(
+                    "multi reply sender is unavailable event_hash=%s",
+                    hashlib.sha256(
+                        str(event.get("event_id", "")).encode("utf-8", "replace")
+                    ).hexdigest()[:12],
+                )
+                return "JWeBot Error: Multi reply unavailable"
+            if not reply_sender(event, response):
+                return "JWeBot Error: Multi reply delivery failed"
+            TELEMETRY.elapsed(
+                "recorder.edge.request",
+                started,
+                event_id=event_id,
+                group_id=group_id,
+                route=str(response.get("route", "")),
+                execution_path=str(response.get("execution_path", "")),
+                chars=sum(len(item) for item in texts),
+                messages=len(texts),
+                outcome="multi_reply",
+            )
+            return "NO_REPLY"
         reply = str(response.get("text", ""))
         if reply and len(reply) <= 900:
             if response.get("fast_ack") is True:
@@ -986,10 +1015,62 @@ def run() -> None:
         )
         return True
 
+    def send_multi_reply(
+        event: dict[str, Any],
+        response: dict[str, Any],
+    ) -> bool:
+        started = time.monotonic()
+        event_id = str(response.get("event_id") or event.get("event_id", ""))
+        expected_group = str(event.get("group_fingerprint", ""))
+        texts = response.get("texts")
+        if (
+            not event_id
+            or not expected_group
+            or not isinstance(texts, list)
+            or not texts
+            or any(not isinstance(item, str) or not item or len(item) > 900 for item in texts)
+        ):
+            logging.error("edge multi reply response was invalid")
+            return False
+        try:
+            for index, text in enumerate(texts, start=1):
+                module.send_reply(
+                    text,
+                    expected_group,
+                    event_id=event_id,
+                    source=f"local-multi-{index}",
+                )
+        except Exception as error:
+            logging.warning(
+                "multi reply GUI delivery failed event_hash=%s error_type=%s",
+                hashlib.sha256(event_id.encode("utf-8", "replace")).hexdigest()[:12],
+                type(error).__name__,
+            )
+            TELEMETRY.elapsed(
+                "recorder.multi_reply.gui",
+                started,
+                status="error",
+                event_id=event_id,
+                group_id=expected_group,
+                messages=len(texts),
+                error_type=type(error).__name__,
+            )
+            return False
+        TELEMETRY.elapsed(
+            "recorder.multi_reply.gui",
+            started,
+            event_id=event_id,
+            group_id=expected_group,
+            messages=len(texts),
+            delivered=True,
+        )
+        return True
+
     module.route_event = lambda event: edge_router_reply(
         event,
         legacy_router=legacy_router,
         fast_ack_sender=send_fast_ack,
+        reply_sender=send_multi_reply,
     )
     wait_for_ready(module)