fix: context overflow - tool result truncation + multi-round halving + auto compact

Changes:
1. tool_loop_agent_runner.py:
   - Truncate tool results > 12000 chars to prevent single-tool context bloat
   - Replace single-round halving with multi-round (up to 5x) aggressive halving
     on token_limit errors, ensuring retry succeeds

2. astrbot_plugin_memory_system/main.py:
   - on_llm_request: add pre-emptive truncation when history > 200k chars (~50k tokens)
     truncates to 20 most recent turns before sending to LLM
   - /compact: enhanced command with modes:
     /compact [N]   - LLM summary compress, keep N recent turns (default 6)
     /compact hard  - fast truncate to 20 recent turns, no LLM cost
     /compact clear - clear all history

Author: Patori Patch Manager

astrbot/core/agent/runners/tool_loop_agent_runner.py

@@ -298,36 +298,63 @@ async def _iter_llm_responses_with_fallback(
                         candidate_id,
                     )
                     try:
-                        _before = len(self.run_context.messages)
-                        # Force halving truncation regardless of threshold
                         from astrbot.core.agent.context.truncator import ContextTruncator
                         _truncator = ContextTruncator()
-                        self.run_context.messages = _truncator.truncate_by_halving(
-                            self.run_context.messages
-                        )
-                        _after = len(self.run_context.messages)
-                        logger.info(
-                            "Forced context truncation: %d -> %d messages, retrying same provider.",
-                            _before, _after,
-                        )
-                        # Retry same candidate once after compression
-                        try:
-                            async for resp in self._iter_llm_responses(include_model=idx == 0):
-                                if resp.is_chunk:
-                                    has_stream_output = True
-                                    yield resp
-                                    continue
-                                yield resp
-                                return
-                            if has_stream_output:
-                                return
-                        except Exception as retry_exc:
-                            last_exception = retry_exc
-                            logger.warning(
-                                "Chat Model %s retry after compression also failed: %s",
-                                candidate_id,
-                                retry_exc,
+                        _before_total = len(self.run_context.messages)
+                        # Aggressively halve until small enough (up to 5 rounds)
+                        _compression_success = False
+                        for _halve_round in range(5):
+                            _before = len(self.run_context.messages)
+                            self.run_context.messages = _truncator.truncate_by_halving(
+                                self.run_context.messages
+                            )
+                            _after = len(self.run_context.messages)
+                            logger.info(
+                                "Forced context truncation round %d: %d -> %d messages.",
+                                _halve_round + 1, _before, _after,
                             )
+                            if _after <= 4:
+                                break  # Can't shrink further
+                            # Retry same candidate
+                            try:
+                                async for resp in self._iter_llm_responses(include_model=idx == 0):
+                                    if resp.is_chunk:
+                                        has_stream_output = True
+                                        yield resp
+                                        continue
+                                    yield resp
+                                    logger.info(
+                                        "Context truncation succeeded after %d round(s): %d -> %d messages.",
+                                        _halve_round + 1, _before_total, _after,
+                                    )
+                                    _compression_success = True
+                                    return
+                                if has_stream_output:
+                                    _compression_success = True
+                                    return
+                                _compression_success = True
+                                break  # succeeded without stream output
+                            except Exception as retry_exc:
+                                _exc_str2 = str(retry_exc).lower()
+                                if not (
+                                    "model_max_prompt_tokens_exceeded" in _exc_str2
+                                    or "prompt token count" in _exc_str2
+                                    or "tokens_exceeded" in _exc_str2
+                                    or "context_length_exceeded" in _exc_str2
+                                    or ("token" in _exc_str2 and "exceed" in _exc_str2)
+                                ):
+                                    last_exception = retry_exc
+                                    logger.warning(
+                                        "Chat Model %s retry after compression failed: %s",
+                                        candidate_id, retry_exc,
+                                    )
+                                    break
+                                last_exception = retry_exc
+                                logger.warning(
+                                    "Chat Model %s still token-exceeded after round %d, halving again...",
+                                    candidate_id, _halve_round + 1,
+                                )
+                                continue
                     except Exception as compress_exc:
                         logger.error("Failed to compress context: %s", compress_exc)
                     continue
@@ -760,6 +787,14 @@ async def _handle_function_tools(
         logger.info(f"Agent 使用工具: {llm_response.tools_call_name}")
 
         def _append_tool_call_result(tool_call_id: str, content: str) -> None:
+            # Truncate oversized tool results to prevent context bloat
+            MAX_TOOL_RESULT_CHARS = 12000
+            if len(content) > MAX_TOOL_RESULT_CHARS:
+                truncated_len = len(content) - MAX_TOOL_RESULT_CHARS
+                content = (
+                    content[:MAX_TOOL_RESULT_CHARS]
+                    + f"\n... [TRUNCATED {truncated_len} chars to prevent context overflow]"
+                )
             tool_call_result_blocks.append(
                 ToolCallMessageSegment(
                     role="tool",

data/plugins/astrbot_plugin_memory_system/main.py

@@ -147,12 +147,35 @@ async def filter_empty_message(
     async def inject_memory_context(
         self, event: AstrMessageEvent, req: ProviderRequest
     ) -> None:
-        """在每次 LLM 请求前将三层记忆注入 system_prompt。"""
+        """在每次 LLM 请求前将三层记忆注入 system_prompt，并在上下文过大时自动截断。"""
+        import json as _json
+
+        # 1. 注入记忆上下文
         block = _build_context_block()
         if block:
             req.system_prompt = (req.system_prompt or "") + block
             logger.debug("[MemorySystem] 已注入记忆上下文（%d chars）", len(block))
 
+        # 2. 预防性历史截断：如果 history 消息总 chars 超过阈值，自动截断旧消息
+        AUTO_COMPACT_CHARS = 200_000  # 约 50k tokens 时自动截断（保守阈值）
+        KEEP_RECENT_TURNS = 20
+        try:
+            if req.contexts:
+                contexts_str = _json.dumps(req.contexts, ensure_ascii=False)
+                if len(contexts_str) > AUTO_COMPACT_CHARS:
+                    from astrbot.core.agent.context.truncator import ContextTruncator
+                    from astrbot.core.agent.message import Message as _Msg
+                    msgs = [_Msg.model_validate(m) if isinstance(m, dict) else m for m in req.contexts]
+                    _truncator = ContextTruncator()
+                    truncated = _truncator.truncate_by_turns(msgs, keep_most_recent_turns=KEEP_RECENT_TURNS)
+                    req.contexts = [m.model_dump() if hasattr(m, "model_dump") else m for m in truncated]
+                    logger.warning(
+                        "[MemorySystem] 自动截断历史上下文：%d -> %d 条消息（原始 %d chars 超过阈值 %d）",
+                        len(msgs), len(truncated), len(contexts_str), AUTO_COMPACT_CHARS,
+                    )
+        except Exception as _e:
+            logger.warning("[MemorySystem] 预防性截断失败（非致命）: %s", _e)
+
     # ════════════════════════════════════════
     #  LLM 工具：写日记
     # ════════════════════════════════════════
@@ -381,16 +404,40 @@ async def cmd_write_diary(
     @filter.command("compact")
     async def cmd_compact(self, event: AstrMessageEvent) -> None:
         """
-        手动触发 LLM Summary 上下文压缩，将当前会话历史压缩为摘要。
-        用法：/compact
+        手动触发上下文压缩。
+        用法：
+          /compact         — LLM 摘要压缩，保留最近 6 轮
+          /compact 10      — LLM 摘要压缩，保留最近 10 轮
+          /compact hard    — 强制截断，只保留最近 20 轮（不消耗 LLM）
+          /compact clear   — 清空全部历史（谨慎！）
         """
         import json
         from astrbot.core.agent.context.compressor import LLMSummaryCompressor
+        from astrbot.core.agent.context.truncator import ContextTruncator
         from astrbot.core.agent.message import Message
 
         umo = event.unified_msg_origin
         conv_mgr = self.context.conversation_manager
 
+        # 解析参数
+        raw_msg = event.message_str.strip()
+        args = raw_msg.split()[1:]  # 去掉 /compact
+        mode = "llm"
+        keep_recent = 6
+        if args:
+            arg0 = args[0].lower()
+            if arg0 == "hard":
+                mode = "hard"
+                keep_recent = 20
+            elif arg0 == "clear":
+                mode = "clear"
+            else:
+                try:
+                    keep_recent = max(2, int(arg0))
+                except ValueError:
+                    yield event.plain_result("⚠️ 参数无效，请用 /compact [数字|hard|clear]")
+                    return
+
         # 1. 获取当前 conversation
         cid = await conv_mgr.get_curr_conversation_id(umo)
         if not cid:
@@ -403,42 +450,72 @@ async def cmd_compact(self, event: AstrMessageEvent) -> None:
             return
 
         history: list[dict] = json.loads(conv.history) if isinstance(conv.history, str) else (conv.history or [])
-        # 过滤掉 system 消息，只保留 user/assistant 轮次
         non_system = [m for m in history if m.get("role") != "system"]
-        if len(non_system) < 4:
-            yield event.plain_result("📭 当前对话内容太少，不需要压缩（少于 4 条非系统消息）～")
+
+        if mode == "clear":
+            await conv_mgr.update_conversation(
+                unified_msg_origin=umo,
+                conversation_id=cid,
+                history=[],
+            )
+            yield event.plain_result(f"🗑️ 已清空全部历史记录（原有 {len(non_system)} 条消息）")
+            return
+
+        if len(non_system) < 2:
+            yield event.plain_result("📭 当前对话内容太少，不需要压缩～")
+            return
+
+        if mode == "hard":
+            # 仅截断，不使用 LLM
+            msgs = [Message.model_validate(m) if isinstance(m, dict) else m for m in history]
+            _truncator = ContextTruncator()
+            truncated = _truncator.truncate_by_turns(msgs, keep_most_recent_turns=keep_recent)
+            result_dicts = [m.model_dump() if hasattr(m, "model_dump") else dict(m) for m in truncated]
+            await conv_mgr.update_conversation(
+                unified_msg_origin=umo,
+                conversation_id=cid,
+                history=result_dicts,
+            )
+            after_cnt = len([m for m in result_dicts if m.get("role") != "system"])
+            yield event.plain_result(
+                f"✂️ 强制截断完成！\n"
+                f"🔹 截断前：{len(non_system)} 条消息\n"
+                f"🔹 截断后：{after_cnt} 条消息（保留最近 {keep_recent} 轮）"
+            )
             return
 
-        # 2. 获取当前 provider
+        # LLM 摘要压缩
         provider = self.context.get_using_provider(umo)
         if not provider:
-            yield event.plain_result("⚠️ 当前没有可用的 LLM Provider，无法进行 LLM 摘要压缩～")
+            yield event.plain_result("⚠️ 当前没有可用的 LLM Provider，尝试用 /compact hard 代替")
             return
 
-        yield event.plain_result(f"🗜️ 正在压缩上下文（共 {len(non_system)} 条消息），请稍等～")
+        chars_before = len(json.dumps(history, ensure_ascii=False))
+        yield event.plain_result(
+            f"🗜️ 正在 LLM 摘要压缩（{len(non_system)} 条消息，约 {chars_before//4:,} tokens），保留最近 {keep_recent} 轮，请稍等～"
+        )
 
-        # 3. 构建 LLMSummaryCompressor 并执行压缩
         compressor = LLMSummaryCompressor(
             provider=provider,
-            keep_recent=4,
+            keep_recent=keep_recent,
         )
-        messages = [Message(**m) if not isinstance(m, Message) else m for m in history]
+        messages = [Message.model_validate(m) if isinstance(m, dict) else m for m in history]
         compressed = await compressor(messages)
 
-        # 4. 写回 conversation
         compressed_dicts = [m.model_dump() if hasattr(m, "model_dump") else dict(m) for m in compressed]
         await conv_mgr.update_conversation(
             unified_msg_origin=umo,
             conversation_id=cid,
             history=compressed_dicts,
         )
 
-        before_cnt = len(non_system)
+        chars_after = len(json.dumps(compressed_dicts, ensure_ascii=False))
         after_cnt = len([m for m in compressed_dicts if m.get("role") != "system"])
         yield event.plain_result(
-            f"✅ 上下文压缩完成！\n"
-            f"🔹 压缩前：{before_cnt} 条消息\n"
-            f"🔹 压缩后：{after_cnt} 条消息（保留了最近 4 轮 + 摘要）"
+            f"✅ LLM 摘要压缩完成！\n"
+            f"🔹 压缩前：{len(non_system)} 条消息 / ~{chars_before//4:,} tokens\n"
+            f"🔹 压缩后：{after_cnt} 条消息 / ~{chars_after//4:,} tokens\n"
+            f"🔹 压缩率：{(1 - chars_after/max(chars_before,1))*100:.1f}%（保留最近 {keep_recent} 轮 + 摘要）"
         )
 
     async def terminate(self) -> None: