feat(cli): support multi-round reply and large response handling

YukiRa1n · YukiRa1n · commit 078dbfb7d15a · 2026-02-01T03:57:23.000+08:00
- Fix client to receive large responses by using loop recv instead of single recv(4096)
- Save base64 images to temp files instead of exposing in JSON response
- Implement adaptive delay mechanism for multi-round reply collection:
  * First send: 5s delay (fast response for simple text)
  * Subsequent sends: 10s delay (auto-switch for tool invocation)
- Support tool invocation scenarios with multiple replies (text + images)
- Add detailed logging for debugging multi-round reply collection
diff --git a/astrbot-cli b/astrbot-cli
@@ -100,10 +100,23 @@ def send_message(
         request_data = json.dumps(request, ensure_ascii=False).encode("utf-8")
         client_socket.sendall(request_data)
 
-        # 接收响应
-        response_data = client_socket.recv(4096)
+        # 接收响应（循环接收所有数据，支持大响应如base64图片）
+        response_data = b""
+        while True:
+            chunk = client_socket.recv(4096)
+            if not chunk:
+                break
+            response_data += chunk
+            # 尝试解析JSON，如果成功说明接收完整
+            try:
+                response = json.loads(response_data.decode("utf-8"))
+                return response
+            except json.JSONDecodeError:
+                # JSON不完整，继续接收
+                continue
+
+        # 如果循环结束仍未成功解析，尝试最后一次
         response = json.loads(response_data.decode("utf-8"))
-
         return response
 
     except TimeoutError:
diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py
@@ -14,7 +14,6 @@
 
 from astrbot import logger
 from astrbot.core.message.components import Plain
-from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path
 from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core.platform import (
     AstrBotMessage,
@@ -24,6 +23,7 @@
     PlatformMetadata,
 )
 from astrbot.core.platform.astr_message_event import MessageSesion
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path
 
 from ...register import register_platform_adapter
 from .cli_event import CLIMessageEvent
@@ -36,7 +36,7 @@
         "type": "cli",
         "enable": False,  # 默认关闭，开发时手动启用
         "mode": "socket",  # 默认使用Socket模式
-        "socket_path": "/tmp/astrbot.sock",
+        "socket_path": None,  # None表示使用动态路径(temp_dir/astrbot.sock)
         "whitelist": [],  # 空白名单表示允许所有
         "use_isolated_sessions": False,  # 是否启用会话隔离（每个请求独立会话）
         "session_ttl": 30,  # 会话过期时间（秒），仅在use_isolated_sessions=True时生效，测试用30秒，生产建议1800秒（30分钟）
@@ -104,10 +104,12 @@ def __init__(
 
         # 文件I/O配置
         self.input_file = platform_config.get(
-            "input_file", "/tmp/astrbot_cli/input.txt"
+            "input_file",
+            os.path.join(get_astrbot_temp_path(), "astrbot_cli", "input.txt"),
         )
         self.output_file = platform_config.get(
-            "output_file", "/tmp/astrbot_cli/output.txt"
+            "output_file",
+            os.path.join(get_astrbot_temp_path(), "astrbot_cli", "output.txt"),
         )
         self.poll_interval = platform_config.get("poll_interval", 1.0)
 
@@ -519,11 +521,39 @@ async def _handle_socket_client(self, client_socket) -> None:
                                     )
                                     image_info["error"] = str(e)
                             elif comp.file.startswith("base64://"):
-                                image_info["type"] = "base64"
-                                # 返回完整的base64数据
-                                base64_data = comp.file[9:]
-                                image_info["base64_data"] = base64_data
-                                image_info["base64_length"] = len(base64_data)
+                                # 将base64数据保存到临时文件，避免在JSON中暴露大量数据
+                                try:
+                                    import base64
+                                    import os
+                                    import tempfile
+
+                                    base64_data = comp.file[9:]
+                                    image_data = base64.b64decode(base64_data)
+
+                                    # 生成临时文件路径
+                                    temp_dir = get_astrbot_temp_path()
+                                    os.makedirs(temp_dir, exist_ok=True)
+                                    temp_file = tempfile.NamedTemporaryFile(
+                                        delete=False,
+                                        suffix=".png",
+                                        dir=temp_dir,
+                                    )
+                                    temp_file.write(image_data)
+                                    temp_file.close()
+
+                                    image_info["type"] = "file"
+                                    image_info["path"] = temp_file.name
+                                    image_info["size"] = len(image_data)
+                                    logger.debug(
+                                        f"[PROCESS] Saved base64 image to file: {temp_file.name}, size: {len(image_data)} bytes"
+                                    )
+                                except Exception as e:
+                                    logger.error(
+                                        f"[ERROR] Failed to save base64 image: {e}"
+                                    )
+                                    image_info["type"] = "base64"
+                                    image_info["error"] = str(e)
+                                    image_info["base64_length"] = len(base64_data)
                         images.append(image_info)
 
                 # 发送成功响应
diff --git a/astrbot/core/platform/sources/cli/cli_event.py b/astrbot/core/platform/sources/cli/cli_event.py
@@ -53,6 +53,11 @@ def __init__(
         self.output_queue = output_queue
         self.response_future = response_future
 
+        # 用于收集多次回复
+        self.send_buffer = None
+        self._response_delay_task = None
+        self._response_delay = 3.0  # 延迟3秒收集所有回复（支持工具调用等多轮场景）
+
         logger.debug("[EXIT] CLIMessageEvent.__init__ return=None")
 
     async def send(self, message_chain: MessageChain) -> dict[str, Any]:
@@ -68,7 +73,7 @@ async def send(self, message_chain: MessageChain) -> dict[str, Any]:
             "[ENTRY] CLIMessageEvent.send inputs={message_chain=%s}", message_chain
         )
 
-        # Socket模式：直接设置Future结果（返回完整MessageChain以支持图片等组件）
+        # Socket模式：收集多次回复
         if self.response_future is not None and not self.response_future.done():
             # 预处理本地文件图片：立即读取并转换为base64（避免临时文件被删除）
             import base64
@@ -100,8 +105,32 @@ async def send(self, message_chain: MessageChain) -> dict[str, Any]:
                             f"[ERROR] Failed to read image file {file_path}: {e}"
                         )
 
-            self.response_future.set_result(message_chain)
-            logger.debug("[PROCESS] Set socket response future with MessageChain")
+            # 收集多次回复到buffer（自适应延迟机制）
+            if not self.send_buffer:
+                # 第一次send：初始化buffer，使用中等延迟（5秒）
+                # 5秒足够等待工具调用的第二次回复，同时不会让简单回复等太久
+                self.send_buffer = message_chain
+                self._response_delay = 5.0
+                logger.info("[PROCESS] First send: initialized buffer with 5s delay")
+            else:
+                # 后续send：追加到buffer，切换到长延迟（10秒）
+                # 确保能收集到所有工具调用的回复
+                self.send_buffer.chain.extend(message_chain.chain)
+                self._response_delay = 10.0
+                logger.info(
+                    f"[PROCESS] Appended to buffer (switched to 10s delay), total: {len(self.send_buffer.chain)} components"
+                )
+
+            # 取消之前的延迟任务（如果存在）
+            if self._response_delay_task and not self._response_delay_task.done():
+                self._response_delay_task.cancel()
+                logger.info("[PROCESS] Cancelled previous delay task")
+
+            # 启动新的延迟任务（每次send都重置延迟）
+            self._response_delay_task = asyncio.create_task(self._delayed_response())
+            logger.info(
+                f"[PROCESS] Started new delay task ({self._response_delay}s)"
+            )
         else:
             # 其他模式：将消息放入输出队列
             await self.output_queue.put(message_chain)
@@ -129,3 +158,38 @@ async def reply(self, message_chain: MessageChain) -> dict[str, Any]:
         logger.debug("[EXIT] CLIMessageEvent.reply return=%s", result)
 
         return result
+
+    async def _delayed_response(self) -> None:
+        """延迟响应：等待一段时间收集所有回复后统一返回
+
+        等待 _response_delay 秒后，将累积的所有消息统一返回给客户端。
+        这样可以支持插件的多轮回复（如先发文本，再发图片）。
+        """
+        logger.debug(
+            "[ENTRY] _delayed_response inputs={delay=%s}", self._response_delay
+        )
+
+        try:
+            # 等待延迟时间，收集所有回复
+            await asyncio.sleep(self._response_delay)
+
+            # 检查 Future 是否还未完成
+            if self.response_future and not self.response_future.done():
+                # 将累积的消息设置到 Future
+                self.response_future.set_result(self.send_buffer)
+                logger.debug(
+                    "[PROCESS] Set delayed response with %d components",
+                    len(self.send_buffer.chain),
+                )
+            else:
+                logger.warning(
+                    "[WARN] Response future already done or None, skipping set_result"
+                )
+
+        except Exception as e:
+            logger.error("[ERROR] Failed to set delayed response: %s", e)
+            # 如果出错，尝试设置异常到 Future
+            if self.response_future and not self.response_future.done():
+                self.response_future.set_exception(e)
+
+        logger.debug("[EXIT] _delayed_response return=None")
