Backend add token compression feat

Author: Newtonian-No

astrbot/core/agent/context/config.py

@@ -23,6 +23,10 @@ class ContextConfig:
     1. Enforce max turns truncation.
     2. Truncation by turns compression strategy.
     """
+    context_limit_type: str = "turn"
+    """Compression trigger mode: "turn" uses model context window × 0.82 rate; "token" uses an absolute token threshold."""
+    compression_token_threshold: int = 4000
+    """When context_limit_type is "token", compression triggers when total tokens >= this threshold."""
     llm_compress_instruction: str | None = None
     """Instruction prompt for LLM-based compression."""
     llm_compress_keep_recent: int = 0

astrbot/core/agent/context/manager.py

@@ -41,6 +41,13 @@ def __init__(
                 truncate_turns=config.truncate_turns
             )
 
+    def _has_compressible_messages(self, messages: list[Message]) -> bool:
+        """Check if there are any compressible (user/assistant) messages beyond system prompts."""
+        for msg in messages:
+            if msg.role in ("user", "assistant"):
+                return True
+        return False
+
     async def process(
         self, messages: list[Message], trusted_token_usage: int = 0
     ) -> list[Message]:
@@ -56,7 +63,11 @@ async def process(
             result = messages
 
             # 1. 基于轮次的截断 (Enforce max turns)
-            if self.config.enforce_max_turns != -1:
+            # Skip turn-based truncation in token mode to avoid conflicts with absolute token threshold
+            if (
+                self.config.context_limit_type != "token"
+                and self.config.enforce_max_turns != -1
+            ):
                 result = self.truncator.truncate_by_turns(
                     result,
                     keep_most_recent_turns=self.config.enforce_max_turns,
@@ -69,10 +80,17 @@ async def process(
                     result, trusted_token_usage
                 )
 
-                if self.compressor.should_compress(
-                    result, total_tokens, self.config.max_context_tokens
-                ):
-                    result = await self._run_compression(result, total_tokens)
+                if self.config.context_limit_type == "token":
+                    if (
+                        self._has_compressible_messages(result)
+                        and total_tokens >= self.config.compression_token_threshold
+                    ):
+                        result = await self._run_compression(result, total_tokens)
+                else:
+                    if self.compressor.should_compress(
+                        result, total_tokens, self.config.max_context_tokens
+                    ):
+                        result = await self._run_compression(result, total_tokens)
 
             return result
         except Exception as e:
@@ -100,21 +118,36 @@ async def _run_compression(
         tokens_after_summary = self.token_counter.count_tokens(messages)
 
         # calculate compress rate
-        compress_rate = (tokens_after_summary / self.config.max_context_tokens) * 100
+        if self.config.context_limit_type == "token":
+            denominator = self.config.compression_token_threshold
+        else:
+            denominator = self.config.max_context_tokens
+        compress_rate = (
+            (tokens_after_summary / denominator) * 100 if denominator > 0 else 0
+        )
         logger.info(
             f"Compress completed."
             f" {prev_tokens} -> {tokens_after_summary} tokens,"
             f" compression rate: {compress_rate:.2f}%.",
         )
 
         # last check
-        if self.compressor.should_compress(
-            messages, tokens_after_summary, self.config.max_context_tokens
-        ):
-            logger.info(
-                "Context still exceeds max tokens after compression, applying halving truncation..."
-            )
-            # still need compress, truncate by half
-            messages = self.truncator.truncate_by_halving(messages)
+        if self.config.context_limit_type == "token":
+            if (
+                self._has_compressible_messages(messages)
+                and tokens_after_summary >= self.config.compression_token_threshold
+            ):
+                logger.info(
+                    "Context still exceeds compression threshold after compression, applying halving truncation..."
+                )
+                messages = self.truncator.truncate_by_halving(messages)
+        else:
+            if self.compressor.should_compress(
+                messages, tokens_after_summary, self.config.max_context_tokens
+            ):
+                logger.info(
+                    "Context still exceeds max tokens after compression, applying halving truncation..."
+                )
+                messages = self.truncator.truncate_by_halving(messages)
 
         return messages

astrbot/core/agent/runners/tool_loop_agent_runner.py

@@ -220,6 +220,9 @@ async def reset(
         llm_compress_provider: Provider | None = None,
         # truncate by turns compressor
         truncate_turns: int = 1,
+        # token-threshold compression
+        context_limit_type: str = "turn",
+        compression_token_threshold: int = 4000,
         # customize
         custom_token_counter: TokenCounter | None = None,
         custom_compressor: ContextCompressor | None = None,
@@ -236,6 +239,8 @@ async def reset(
         self.llm_compress_keep_recent = llm_compress_keep_recent
         self.llm_compress_provider = llm_compress_provider
         self.truncate_turns = truncate_turns
+        self.context_limit_type = context_limit_type
+        self.compression_token_threshold = compression_token_threshold
         self.custom_token_counter = custom_token_counter
         self.custom_compressor = custom_compressor
         self.tool_result_overflow_dir = tool_result_overflow_dir
@@ -250,6 +255,8 @@ async def reset(
             # enforce max turns before compression
             enforce_max_turns=self.enforce_max_turns,
             truncate_turns=self.truncate_turns,
+            context_limit_type=self.context_limit_type,
+            compression_token_threshold=self.compression_token_threshold,
             llm_compress_instruction=self.llm_compress_instruction,
             llm_compress_keep_recent=self.llm_compress_keep_recent,
             llm_compress_provider=self.llm_compress_provider,

astrbot/core/astr_main_agent.py

@@ -161,6 +161,10 @@ class MainAgentBuildConfig:
     """The number of oldest turns to remove when context length limit is reached."""
     fallback_max_context_tokens: int = 128000
     """Fallback max context tokens. When max_context_tokens is 0 and the model is not in LLM_METADATAS, use this value."""
+    context_limit_type: str = "turn"
+    """Compression trigger mode: "turn" uses model context window × 0.82 rate; "token" uses an absolute token threshold."""
+    compression_token_threshold: int = 4000
+    """When context_limit_type is "token", compression triggers when total tokens >= this threshold."""
     llm_safety_mode: bool = True
     """This will inject healthy and safe system prompt into the main agent,
     to prevent LLM output harmful information"""
@@ -1473,6 +1477,8 @@ async def build_main_agent(
         llm_compress_provider=_get_compress_provider(config, plugin_context),
         truncate_turns=config.dequeue_context_length,
         enforce_max_turns=config.max_context_length,
+        context_limit_type=config.context_limit_type,
+        compression_token_threshold=config.compression_token_threshold,
         tool_schema_mode=config.tool_schema_mode,
         fallback_providers=_get_fallback_chat_providers(
             provider, plugin_context, config.provider_settings

astrbot/core/config/default.py

@@ -132,6 +132,8 @@
         "llm_compress_provider_id": "",
         "max_context_length": -1,
         "dequeue_context_length": 1,
+        "context_limit_type": "turn",
+        "compression_token_threshold": 4000,
         "streaming_response": False,
         "show_tool_use_status": False,
         "show_tool_call_result": False,
@@ -3509,6 +3511,7 @@
                         "type": "int",
                         "hint": "超出这个数量时丢弃最旧的部分，一轮聊天记为 1 条，-1 为不限制",
                         "condition": {
+                            "provider_settings.context_limit_type": "turn",
                             "provider_settings.agent_runner_type": "local",
                         },
                     },
@@ -3566,6 +3569,25 @@
                             "provider_settings.agent_runner_type": "local",
                         },
                     },
+                    "provider_settings.context_limit_type": {
+                        "description": "上下文压缩触发模式",
+                        "type": "string",
+                        "options": ["turn", "token"],
+                        "labels": ["按百分比（模型窗口 × 82%）", "按固定 Token 阈值"],
+                        "hint": '"按百分比"为默认行为：当上下文 Token 数超过模型窗口的 82% 时触发压缩。"按固定 Token 阈值"允许您设置一个绝对的 Token 数作为触发阈值，适用于需要更早触发压缩的场景。',
+                        "condition": {
+                            "provider_settings.agent_runner_type": "local",
+                        },
+                    },
+                    "provider_settings.compression_token_threshold": {
+                        "description": "Token 触发阈值",
+                        "type": "int",
+                        "hint": '当"上下文压缩触发模式"设为"按固定 Token 阈值"时生效。当前上下文 Token 数达到此值时触发压缩。',
+                        "condition": {
+                            "provider_settings.context_limit_type": "token",
+                            "provider_settings.agent_runner_type": "local",
+                        },
+                    },
                 },
                 "condition": {
                     "provider_settings.agent_runner_type": "local",

astrbot/core/pipeline/process_stage/method/agent_sub_stages/internal.py

@@ -111,6 +111,10 @@ async def initialize(self, ctx: PipelineContext) -> None:
         self.fallback_max_context_tokens: int = settings.get(
             "fallback_max_context_tokens", 128000
         )
+        self.context_limit_type: str = settings.get("context_limit_type", "turn")
+        self.compression_token_threshold: int = settings.get(
+            "compression_token_threshold", 4000
+        )
 
         self.llm_safety_mode = settings.get("llm_safety_mode", True)
         self.safety_mode_strategy = settings.get(
@@ -141,6 +145,8 @@ async def initialize(self, ctx: PipelineContext) -> None:
             max_context_length=self.max_context_length,
             dequeue_context_length=self.dequeue_context_length,
             fallback_max_context_tokens=self.fallback_max_context_tokens,
+            context_limit_type=self.context_limit_type,
+            compression_token_threshold=self.compression_token_threshold,
             llm_safety_mode=self.llm_safety_mode,
             safety_mode_strategy=self.safety_mode_strategy,
             computer_use_runtime=self.computer_use_runtime,

dashboard/src/i18n/locales/en-US/features/config-metadata.json

@@ -276,6 +276,18 @@
         "fallback_max_context_tokens": {
           "description": "Fallback context window size",
           "hint": "When max_context_tokens is 0 and the model is not in built-in metadata, use this value as the context window size. Default: 128000."
+        },
+        "context_limit_type": {
+          "description": "Compression Trigger Mode",
+          "labels": [
+            "By Percentage (Model Window × 82%)",
+            "By Fixed Token Threshold"
+          ],
+          "hint": "\"By Percentage\" is the default behavior. \"By Fixed Token Threshold\" allows setting an absolute token count as the trigger point."
+        },
+        "compression_token_threshold": {
+          "description": "Token Trigger Threshold",
+          "hint": "Effective when trigger mode is set to \"By Fixed Token Threshold\". Compression triggers when the current context token count reaches this value."
         }
       }
     },

dashboard/src/i18n/locales/zh-CN/features/config-metadata.json

@@ -278,6 +278,18 @@
         "fallback_max_context_tokens": {
           "description": "上下文窗口兜底值",
           "hint": "当 max_context_tokens 为 0 且模型不在内置元数据中时，使用此值作为上下文窗口大小。默认 128000。"
+        },
+        "context_limit_type": {
+          "description": "上下文压缩触发模式",
+          "labels": [
+            "按百分比（模型窗口 × 82%）",
+            "按固定 Token 阈值"
+          ],
+          "hint": "\"按百分比\"为默认行为。\"按固定 Token 阈值\"允许设置绝对的 Token 数作为触发阈值。"
+        },
+        "compression_token_threshold": {
+          "description": "Token 触发阈值",
+          "hint": "当触发模式为\"按固定 Token 阈值\"时生效，当前上下文 Token 数达到此值时触发压缩。"
         }
       }
     },