feat: 支持回复频率为零时静默接收

Author: SengokuCola

pytests/test_maisaka_timing_gate.py

@@ -4,11 +4,16 @@
 import asyncio
 import pytest
 
+from src.chat.heart_flow.heartFC_utils import CycleDetail
+from src.common.utils.utils_config import ChatConfigUtils
+from src.config.config import global_config
 from src.core.tooling import ToolAvailabilityContext, ToolExecutionResult, ToolInvocation
 from src.llm_models.payload_content.tool_option import ToolCall
+from src.maisaka import reasoning_engine as reasoning_engine_module
 from src.maisaka.builtin_tool import get_timing_tools
 from src.maisaka.chat_loop_service import ChatResponse, MaisakaChatLoopService
 from src.maisaka.context_messages import AssistantMessage, TIMING_GATE_INVALID_TOOL_HINT_SOURCE
+from src.maisaka.history_post_processor import HistoryPostProcessResult
 from src.maisaka.reasoning_engine import MaisakaReasoningEngine
 from src.maisaka.runtime import MaisakaHeartFlowChatting
 
@@ -238,6 +243,7 @@ def test_forced_timing_trigger_bypasses_message_frequency_threshold() -> None:
         _internal_turn_queue=asyncio.Queue(),
         _has_pending_messages=lambda: True,
         _get_pending_message_count=lambda: 1,
+        _is_reply_frequency_silent=lambda: False,
         _has_forced_timing_trigger=lambda: True,
         _cancel_deferred_message_turn_task=lambda: None,
     )
@@ -253,6 +259,110 @@ def _fail_get_message_trigger_threshold() -> int:
     assert runtime._internal_turn_queue.get_nowait() == "message"
 
 
+def test_zero_reply_frequency_keeps_effective_zero(monkeypatch: pytest.MonkeyPatch) -> None:
+    runtime = object.__new__(MaisakaHeartFlowChatting)
+    runtime.session_id = "test-session"
+    runtime.chat_stream = SimpleNamespace(is_group_session=True)
+    runtime._talk_frequency_adjust = 1.0
+
+    monkeypatch.setattr(global_config.chat, "talk_value", 0.0)
+    monkeypatch.setattr(
+        ChatConfigUtils,
+        "get_talk_value",
+        staticmethod(lambda session_id, is_group_chat=None: 1.0),
+    )
+
+    assert runtime._get_effective_reply_frequency() == 0.0
+    assert runtime._is_reply_frequency_silent() is True
+
+
+def test_zero_reply_frequency_schedules_silent_turn_before_forced_trigger() -> None:
+    runtime = SimpleNamespace(
+        _STATE_WAIT="wait",
+        _agent_state="stop",
+        _message_turn_scheduled=False,
+        _internal_turn_queue=asyncio.Queue(),
+        _has_pending_messages=lambda: True,
+        _get_pending_message_count=lambda: 1,
+        _is_reply_frequency_silent=lambda: True,
+        _cancel_deferred_message_turn_task=lambda: None,
+    )
+
+    def _fail_has_forced_timing_trigger() -> bool:
+        raise AssertionError("回复频率为 0 时不应进入 @/提及强制触发分支")
+
+    runtime._has_forced_timing_trigger = _fail_has_forced_timing_trigger
+
+    MaisakaHeartFlowChatting._schedule_message_turn(runtime)  # type: ignore[arg-type]
+
+    assert runtime._message_turn_scheduled is True
+    assert runtime._internal_turn_queue.get_nowait() == "message"
+
+
+@pytest.mark.asyncio
+async def test_silent_post_process_skips_mid_term_summary_but_keeps_learning(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    removed_messages = [SimpleNamespace(count_in_context=True)]
+    final_history = [SimpleNamespace(count_in_context=True)]
+    process_result = HistoryPostProcessResult(
+        history=final_history,
+        removed_messages=removed_messages,
+        removed_count=1,
+        changed_count=1,
+        remaining_context_count=1,
+    )
+    trim_logs: list[tuple[int, int]] = []
+    learning_messages: list[object] = []
+
+    async def _fake_trigger_learning(messages: object) -> None:
+        learning_messages.append(messages)
+
+    runtime = SimpleNamespace(
+        _chat_history=[SimpleNamespace(count_in_context=True)],
+        _max_context_size=1,
+        log_prefix="[test]",
+        session_id="test-session",
+        _log_history_trimmed=lambda removed_count, remaining_count: trim_logs.append(
+            (removed_count, remaining_count)
+        ),
+        _trigger_trimmed_history_learning=_fake_trigger_learning,
+    )
+    engine = MaisakaReasoningEngine(runtime)  # type: ignore[arg-type]
+    scheduled_coroutines: list[object] = []
+
+    def _fake_create_task(coro: object) -> SimpleNamespace:
+        scheduled_coroutines.append(coro)
+        return SimpleNamespace()
+
+    async def _fail_build_mid_term_memory_message(*args: object, **kwargs: object) -> None:
+        del args, kwargs
+        raise AssertionError("静默模式裁切历史不应生成中期记忆摘要")
+
+    monkeypatch.setattr(
+        reasoning_engine_module,
+        "process_chat_history_after_cycle",
+        lambda *args, **kwargs: process_result,
+    )
+    monkeypatch.setattr(
+        reasoning_engine_module,
+        "build_mid_term_memory_message",
+        _fail_build_mid_term_memory_message,
+    )
+    monkeypatch.setattr(reasoning_engine_module.asyncio, "create_task", _fake_create_task)
+
+    await engine._post_process_chat_history_after_cycle(
+        CycleDetail(cycle_id=1),
+        enable_mid_term_memory=False,
+    )
+    for coro in scheduled_coroutines:
+        await coro
+
+    assert runtime._chat_history == final_history
+    assert trim_logs == [(1, 1)]
+    assert learning_messages == [removed_messages]
+
+
 def test_finish_tool_is_not_written_back_to_history() -> None:
     finish_call = ToolCall(call_id="finish-call", func_name="finish", args={})
     reply_call = ToolCall(call_id="reply-call", func_name="reply", args={})

src/maisaka/builtin_tool/send_emoji.py

@@ -381,6 +381,7 @@ async def _select_emoji_with_sub_agent(
     selection_duration_ms = round((datetime.now() - selection_started_at).total_seconds() * 1000, 2)
 
     selection_metrics: Dict[str, Any] = {
+        "model_name": getattr(response, "model_name", "") or "",
         "prompt_tokens": response.prompt_tokens,
         "completion_tokens": response.completion_tokens,
         "total_tokens": response.total_tokens,

src/maisaka/reasoning_engine.py

@@ -472,9 +472,12 @@ async def run_loop(self) -> None:
                 message_triggered, timeout_triggered, proactive_triggered = self._drain_ready_turn_triggers(
                     queued_trigger
                 )
+                silent_reply_frequency = self._runtime._is_reply_frequency_silent()
 
-                if self._runtime._agent_state == self._runtime._STATE_WAIT and not (
-                    timeout_triggered or proactive_triggered
+                if (
+                    self._runtime._agent_state == self._runtime._STATE_WAIT
+                    and not (timeout_triggered or proactive_triggered)
+                    and not silent_reply_frequency
                 ):
                     self._runtime._message_turn_scheduled = False
                     logger.debug(f"{self._runtime.log_prefix} 当前仍处于 wait 状态，忽略消息触发并继续等待超时")
@@ -516,6 +519,14 @@ async def run_loop(self) -> None:
                             self._build_wait_completed_message(has_new_messages=False)
                         )
 
+                if silent_reply_frequency:
+                    await self._handle_silent_turn(
+                        cached_messages=cached_messages,
+                        timeout_triggered=timeout_triggered,
+                        proactive_triggered=proactive_triggered,
+                    )
+                    continue
+
                 try:
                     timing_gate_required = self._is_independent_timing_gate_enabled()
                     if not timing_gate_required:
@@ -874,6 +885,41 @@ async def run_loop(self) -> None:
             logger.error(traceback.format_exc())
             raise
 
+    async def _handle_silent_turn(
+        self,
+        *,
+        cached_messages: list[SessionMessage],
+        timeout_triggered: bool,
+        proactive_triggered: bool,
+    ) -> None:
+        """回复频率为 0 时只消费消息和维护历史，不进入 Timing Gate/Planner。"""
+
+        self._runtime._clear_force_next_timing_continue_state()
+        if proactive_triggered:
+            self._runtime._proactive_anchor_message = None
+
+        cycle_detail = CycleDetail(cycle_id=self._runtime._cycle_counter)
+        await self._post_process_chat_history_after_cycle(
+            cycle_detail,
+            enable_mid_term_memory=False,
+        )
+        self._runtime._enter_stop_state()
+        if self._runtime._running:
+            self._runtime._update_stage_status("等待消息", "回复频率为 0，已静默接收消息")
+
+        trigger_labels: list[str] = []
+        if cached_messages:
+            trigger_labels.append(f"消息={len(cached_messages)}")
+        if timeout_triggered:
+            trigger_labels.append("wait_timeout")
+        if proactive_triggered:
+            trigger_labels.append("proactive")
+        trigger_text = " ".join(trigger_labels) if trigger_labels else "无新消息"
+        logger.info(
+            f"{self._runtime.log_prefix} 回复频率为 0，静默接收并完成历史维护，"
+            f"不进入 Timing Gate/Planner；{trigger_text}"
+        )
+
     def _drain_ready_turn_triggers(
         self,
         queued_trigger: Literal["message", "timeout", "proactive"],
@@ -1087,7 +1133,12 @@ async def _end_cycle(self, cycle_detail: CycleDetail, only_long_execution: bool
         self._runtime._log_cycle_completed(cycle_detail, timer_strings)
         return cycle_detail
 
-    async def _post_process_chat_history_after_cycle(self, cycle_detail: CycleDetail) -> None:
+    async def _post_process_chat_history_after_cycle(
+        self,
+        cycle_detail: CycleDetail,
+        *,
+        enable_mid_term_memory: bool = True,
+    ) -> None:
         """裁剪聊天历史，保证用户消息数量不超过配置限制。"""
         process_result = process_chat_history_after_cycle(
             self._runtime._chat_history,
@@ -1098,7 +1149,11 @@ async def _post_process_chat_history_after_cycle(self, cycle_detail: CycleDetail
             return
 
         final_history = process_result.history
-        if process_result.removed_messages and bool(global_config.chat.mid_term_memory):
+        if (
+            process_result.removed_messages
+            and enable_mid_term_memory
+            and bool(global_config.chat.mid_term_memory)
+        ):
             logger.info(
                 f"{self._runtime.log_prefix} 开始生成中期聊天记录摘要: "
                 f"裁切上下文消息数量={len(process_result.removed_messages)} "