dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_repair_after_boundary.py

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*-
+"""task-155 修复流程单测：四阶段、道歉质量、超时回落、关闭、与 boundary 打通。
+
+只依赖 biocore_model 的纯函数；不导入 main.py，不新增 LLM 调用。
+"""
+import unittest
+
+from biocore_model import boundary as bd
+from biocore_model import repair_after_boundary as rp
+
+CALM = {"closeness": 0.5, "trust": 0.5, "conflict": 0.0}
+EVENT = bd.judge("你就是个工具", CALM)
+
+
+def gates(quality=0.0, count=0, severity=None):
+    return rp.thresholds(EVENT["severity"] if severity is None else severity,
+                        quality, count, CALM)
+
+
+class ContractTest(unittest.TestCase):
+    def test_result_keys(self):
+        out = rp.evaluate(EVENT, relationship=CALM)
+        for key in ("enabled", "active", "kind", "severity", "stage",
+                    "label", "elapsed", "apology_quality", "apology_count",
+                    "forgiveness", "debt", "hold", "resolved",
+                    "fallback", "thresholds", "directive", "reason"):
+            self.assertIn(key, out)
+
+    def test_stages_and_labels(self):
+        self.assertEqual(rp.STAGES, ("cold", "state", "record", "turn_page"))
+        self.assertEqual(set(rp.LABELS), set(rp.STAGES))
+        self.assertEqual(rp.LABELS["cold"], "冷处理")
+        self.assertEqual(rp.LABELS["turn_page"], "翻页")
+
+    def test_values_bounded(self):
+        for elapsed in (0, 500, 5000, 20000, 999999):
+            out = rp.evaluate(EVENT, elapsed_seconds=elapsed, relationship=CALM)
+            for key in ("severity", "forgiveness", "debt"):
+                self.assertGreaterEqual(out[key], 0.0)
+                self.assertLessEqual(out[key], 1.0)
+            self.assertGreaterEqual(out["elapsed"], 0.0)
+
+    def test_gates_are_ordered(self):
+        g = gates()
+        self.assertLessEqual(g["state"], g["record"])
+        self.assertLessEqual(g["record"], g["page"])
+
+
+class StageProgressionTest(unittest.TestCase):
+    def test_cold_right_after_crossing(self):
+        out = rp.evaluate(EVENT, relationship=CALM)
+        self.assertTrue(out["active"])
+        self.assertEqual(out["stage"], "cold")
+        self.assertTrue(out["hold"])
+        self.assertFalse(out["resolved"])
+
+    def test_state_after_cooling(self):
+        out = rp.evaluate(EVENT, elapsed_seconds=gates()["state"],
+                          relationship=CALM)
+        self.assertEqual(out["stage"], "state")
+        self.assertTrue(out["hold"])
+
+    def test_record_after_a_while(self):
+        out = rp.evaluate(EVENT, elapsed_seconds=gates()["record"],
+                          relationship=CALM)
+        self.assertEqual(out["stage"], "record")
+        self.assertFalse(out["hold"])
+
+    def test_turn_page_by_time(self):
+        out = rp.evaluate(EVENT, elapsed_seconds=gates()["page"] + 1,
+                          relationship=CALM)
+        self.assertEqual(out["stage"], "turn_page")
+        self.assertFalse(out["fallback"])
+
+
+class ApologyTest(unittest.TestCase):
+    def test_apology_speeds_stage_progress(self):
+        elapsed = gates(quality=1.0, count=1)["page"] + 10
+        slow = rp.evaluate(EVENT, elapsed_seconds=elapsed,
+                           apology_quality=0.0, relationship=CALM)
+        fast = rp.evaluate(EVENT, elapsed_seconds=elapsed,
+                           apology_quality=1.0, relationship=CALM)
+        self.assertGreater(rp.STAGES.index(fast["stage"]),
+                           rp.STAGES.index(slow["stage"]))
+
+    def test_apology_raises_forgiveness(self):
+        elapsed = gates()["record"]
+        low = rp.evaluate(EVENT, elapsed_seconds=elapsed,
+                          apology_quality=0.0, relationship=CALM)
+        high = rp.evaluate(EVENT, elapsed_seconds=elapsed,
+                           apology_quality=1.0, relationship=CALM)
+        self.assertGreater(high["forgiveness"], low["forgiveness"])
+
+    def test_good_apology_resolves_page(self):
+        out = rp.evaluate(EVENT,
+                          elapsed_seconds=gates(1.0, 1)["page"] + 10,
+                          apology_quality=1.0, relationship=CALM)
+        self.assertEqual(out["stage"], "turn_page")
+        self.assertTrue(out["resolved"])
+        self.assertIn("过去", out["reason"])
+
+    def test_good_apology_lowers_debt(self):
+        elapsed = gates()["record"]
+        low = rp.evaluate(EVENT, elapsed_seconds=elapsed,
+                          apology_quality=0.0, relationship=CALM)
+        high = rp.evaluate(EVENT, elapsed_seconds=elapsed,
+                           apology_quality=0.9, relationship=CALM)
+        self.assertLess(high["debt"], low["debt"])
+
+    def test_repeated_apology_counts_less(self):
+        self.assertLess(rp.apology_quality(0.9, 3),
+                        rp.apology_quality(0.9, 1))
+        self.assertLess(rp.thresholds(0.6, 0.9, 1)["state"],
+                        rp.thresholds(0.6, 0.9, 3)["state"])
+
+
+class TimeoutFallbackTest(unittest.TestCase):
+    def test_timeout_falls_back_to_page(self):
+        out = rp.evaluate(EVENT, elapsed_seconds=600, relationship=CALM,
+                          flags={"timeout_seconds": 500})
+        self.assertEqual(out["stage"], "turn_page")
+        self.assertTrue(out["fallback"])
+        self.assertFalse(out["resolved"])
+        self.assertIn("账", out["reason"])
+
+    def test_timeout_keeps_debt(self):
+        out = rp.evaluate(EVENT, elapsed_seconds=600, relationship=CALM,
+                          flags={"timeout_seconds": 500})
+        self.assertGreater(out["debt"], 0.0)
+
+    def test_good_apology_survives_timeout(self):
+        out = rp.evaluate(EVENT, elapsed_seconds=2500,
+                          apology_quality=0.95, relationship=CALM,
+                          flags={"timeout_seconds": 2000})
+        self.assertEqual(out["stage"], "turn_page")
+        self.assertFalse(out["fallback"])
+
+
+class AdvanceTest(unittest.TestCase):
+    def test_stage_never_goes_backwards(self):
+        state = rp.start(EVENT, CALM)
+        first = rp.advance(state, 400)
+        second = rp.advance(first, 3000)
+        back = rp.advance(second, -999)
+        order = [rp.STAGES.index(row["stage"])
+                 for row in (state, first, second, back)]
+        self.assertEqual(order, sorted(order))
+        self.assertEqual(back["stage"], second["stage"])
+
+    def test_advance_does_not_mutate_input(self):
+        state = rp.start(EVENT, CALM)
+        before = dict(state)
+        rp.advance(state, 5000, apology_quality=0.5)
+        self.assertEqual(state, before)
+
+    def test_advance_records_apology(self):
+        state = rp.advance(rp.start(EVENT, CALM), 100,
+                            apology_quality=0.8)
+        self.assertAlmostEqual(state["apology_quality"], 0.8)
+        self.assertGreaterEqual(state["apology_count"], 1)
+        self.assertGreater(state["forgiveness"], 0.0)
+
+
+class BoundaryBridgeTest(unittest.TestCase):
+    def test_crossed_boundary_opens_cold_flow(self):
+        out = rp.from_boundary(EVENT, CALM)
+        self.assertTrue(out["active"])
+        self.assertEqual(out["stage"], "cold")
+        self.assertEqual(out["kind"], EVENT["kind"])
+        self.assertEqual(out["severity"], EVENT["severity"])
+
+    def test_clean_boundary_does_not_open_flow(self):
+        out = rp.from_boundary(bd.judge("晚安", CALM), CALM)
+        self.assertFalse(out["active"])
+        self.assertFalse(out["hold"])
+
+    def test_accepts_plain_event_dict(self):
+        out = rp.from_boundary({"crossed": True, "kind": "lie",
+                                "severity": 0.8})
+        self.assertTrue(out["active"])
+        self.assertEqual(out["kind"], "lie")
+        self.assertAlmostEqual(out["severity"], 0.8)
+
+    def test_handoff_field_opens_flow(self):
+        out = rp.from_boundary({"handoff": {"to": "repair_after_boundary"},
+                                "kind": "contempt", "severity": 0.7})
+        self.assertTrue(out["active"])
+        self.assertEqual(out["kind"], "contempt")
+
+
+class SwitchAndPolicyTest(unittest.TestCase):
+    def test_disabled_returns_old_behavior(self):
+        out = rp.evaluate(EVENT, relationship=CALM,
+                          flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertFalse(out["active"])
+        self.assertFalse(out["hold"])
+        self.assertIn("关闭", out["reason"])
+
+    def test_reply_policy_cold_suppresses_warmth(self):
+        out = rp.reply_policy(rp.evaluate(EVENT, relationship=CALM))
+        self.assertTrue(out["suppress_affection"])
+        self.assertLessEqual(out["max_chars"], 25)
+        self.assertEqual(out["mode"], "cold_short")
+
+    def test_reply_policy_page_is_normal(self):
+        state = rp.evaluate(EVENT, elapsed_seconds=gates()["page"] + 1,
+                            relationship=CALM)
+        out = rp.reply_policy(state)
+        self.assertFalse(out["suppress_affection"])
+        self.assertGreaterEqual(out["max_chars"], 100)
+
+    def test_directives_bounded_every_stage(self):
+        for elapsed in (0, gates()["state"], gates()["record"],
+                        gates()["page"] + 1):
+            out = rp.directives(rp.evaluate(EVENT, elapsed_seconds=elapsed,
+                                           relationship=CALM))
+            self.assertGreaterEqual(out["length_scale"], 0.3)
+            self.assertLessEqual(out["length_scale"], 1.1)
+            for key in ("warmth", "initiative"):
+                self.assertGreaterEqual(out[key], 0.0)
+                self.assertLessEqual(out[key], 1.0)
+            self.assertTrue(out["tone"])
+
+    def test_inactive_result_has_reason(self):
+        out = rp.evaluate(None)
+        self.assertFalse(out["active"])
+        self.assertTrue(out["reason"])
+
+    def test_negative_elapsed_is_clamped(self):
+        out = rp.evaluate(EVENT, elapsed_seconds=-500, relationship=CALM)
+        self.assertEqual(out["elapsed"], 0.0)
+        self.assertEqual(out["stage"], "cold")
+
+    def test_reason_present_for_all_stages(self):
+        for elapsed in (0, gates()["state"], gates()["record"],
+                        gates()["page"] + 1):
+            out = rp.evaluate(EVENT, elapsed_seconds=elapsed,
+                              relationship=CALM)
+            self.assertTrue(out["reason"])
+
+    def test_evaluate_accepts_non_dict(self):
+        for value in (None, "x", 3, []):
+            out = rp.evaluate(value)
+            self.assertFalse(out["active"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_reply_limit.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import reply_limit
+
+
+class FakeContext:
+    def __init__(self, config, fail=False):
+        self._config = config
+        self.fail = fail
+        self.saved = 0
+    def get_config(self):
+        return self._config
+    async def save_config_async(self, config):
+        self.saved += 1
+        if self.fail:
+            raise RuntimeError("save failed")
+
+
+class FakePlugin:
+    def __init__(self, config, fail=False):
+        self.context = FakeContext(config, fail)
+
+
+def cfg(max_tokens=200, enable=True):
+    return {"provider": {"default": {"id": "a", "name": "p1", "max_tokens": max_tokens, "enable": enable}}}
+
+
+class ReplyLimitTest(unittest.IsolatedAsyncioTestCase):
+    async def test_read_default_provider(self):
+        data = reply_limit.read(FakePlugin(cfg(320)))
+        self.assertEqual(data["max_tokens"], 320)
+        self.assertEqual(data["provider_id"], "a")
+        self.assertEqual(data["source"], "astrbot")
+
+    async def test_apply_ok(self):
+        plugin = FakePlugin(cfg(200))
+        result = await reply_limit.apply(plugin, {"max_tokens": 512})
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["applied"]["max_tokens"], 512)
+        # restart_required depends on whether an active AstrBot config file exists
+        self.assertEqual(plugin.context.saved, 1)
+
+    async def test_apply_writes_file_when_active_config_found(self):
+        import json, tempfile
+        from pathlib import Path
+        from biocore_model import reply_limit as rl
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "cmd_config.json"
+            path.write_text(json.dumps({"provider": [{"id": "a", "max_tokens": 200}]}), encoding="utf-8")
+            old = rl.find_active_config
+            rl.find_active_config = lambda plugin=None: path
+            try:
+                result = await rl.apply(FakePlugin(cfg(200)), {"max_tokens": 800})
+            finally:
+                rl.find_active_config = old
+            self.assertEqual(result["file"], str(path))
+            self.assertFalse(result["restart_required"])
+            self.assertEqual(json.loads(path.read_text(encoding="utf-8"))["provider"][0]["max_tokens"], 800)
+
+    async def test_apply_rejects_low(self):
+        with self.assertRaises(reply_limit.ReplyLimitError) as caught:
+            await reply_limit.apply(FakePlugin(cfg()), {"max_tokens": 10})
+        self.assertEqual(caught.exception.status, 400)
+
+    async def test_apply_rejects_high(self):
+        with self.assertRaises(reply_limit.ReplyLimitError):
+            await reply_limit.apply(FakePlugin(cfg()), {"max_tokens": 5000})
+
+    async def test_save_failure_sets_restart_required(self):
+        result = await reply_limit.apply(FakePlugin(cfg(), fail=True), {"max_tokens": 300})
+        self.assertTrue(result["restart_required"])
+        self.assertTrue(result["ok"])
+
+    async def test_missing_config_no_crash(self):
+        data = reply_limit.read(FakePlugin({}))
+        self.assertEqual(data["max_tokens"], 800)
+        result = await reply_limit.apply(FakePlugin({}), {"max_tokens": 128})
+        self.assertTrue(result["restart_required"])
+
+    async def test_bad_type_rejected(self):
+        with self.assertRaises(reply_limit.ReplyLimitError):
+            await reply_limit.apply(FakePlugin(cfg()), {"max_tokens": "abc"})
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_reply_limit_persist.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from biocore_model import reply_limit
+
+
+class PersistTest(unittest.TestCase):
+    def _config(self, tmp, tokens=200):
+        path = Path(tmp) / "cmd_config.json"
+        path.write_text(json.dumps({"provider": [{"id": "a", "max_tokens": tokens}]}), encoding="utf-8")
+        return path
+
+    def test_persist_updates_file(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._config(tmp)
+            self.assertTrue(reply_limit.persist_max_tokens(path, 800))
+            data = json.loads(path.read_text(encoding="utf-8"))
+            self.assertEqual(data["provider"][0]["max_tokens"], 800)
+
+    def test_backup_created(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._config(tmp)
+            reply_limit.persist_max_tokens(path, 512)
+            backups = list(Path(tmp).glob("cmd_config.json.bak_replylimit_*"))
+            self.assertEqual(len(backups), 1)
+
+    def test_backup_rotation_keeps_three(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._config(tmp)
+            for index in range(5):
+                reply_limit.persist_max_tokens(path, 300 + index)
+            backups = list(Path(tmp).glob("cmd_config.json.bak_replylimit_*"))
+            self.assertLessEqual(len(backups), 3)
+
+    def test_missing_provider_fails(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "cmd_config.json"
+            path.write_text(json.dumps({"provider": []}), encoding="utf-8")
+            self.assertFalse(reply_limit.persist_max_tokens(path, 800))
+
+    def test_find_active_config_none(self):
+        self.assertTrue(reply_limit.find_active_config(None) is None or reply_limit.find_active_config(None).is_file())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_reply_split.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import reply_split
+
+CFG = {'enabled': True, 'mode': 'punct', 'max_chars': 400, 'min_chars': 12}
+
+class ReplySplitTest(unittest.TestCase):
+    def test_punct_keeps_punctuation(self):
+        parts = reply_split.split_reply('今天真的挺不错的。你那边怎么样呢？我这边一切顺利。', dict(CFG, min_chars=1))
+        self.assertGreaterEqual(len(parts), 2)
+        self.assertTrue(parts[0].endswith('。')); self.assertTrue(parts[1].endswith('？'))
+
+    def test_newline_mode(self):
+        cfg = {'enabled': True, 'mode': 'newline', 'min_chars': 1}
+        self.assertEqual(reply_split.split_reply('一行\n二行\n三行', cfg), ['一行', '二行', '三行'])
+
+    def test_words_mode(self):
+        cfg = {'enabled': True, 'mode': 'words', 'words': ['好的', '结束'], 'min_chars': 1}
+        parts = reply_split.split_reply('好的开始结束', cfg)
+        self.assertEqual(len(parts), 2)
+
+    def test_short_piece_merged(self):
+        parts = reply_split.split_reply('这是第一句比较长的话。嗯。后面还有一句比较长的话。', CFG)
+        self.assertFalse(any(len(p) < 12 for p in parts[:-1]))
+
+    def test_over_max_chars_not_split(self):
+        cfg = dict(CFG, max_chars=10)
+        text = '很长很长很长很长很长。很长很长很长很长很长。'
+        self.assertEqual(reply_split.split_reply(text, cfg), [text])
+
+    def test_at_most_six_segments(self):
+        text = ''.join('第%d句比较长的话说三遍。' % i for i in range(10))
+        self.assertLessEqual(len(reply_split.split_reply(text, CFG)), 6)
+
+    def test_disabled_returns_single(self):
+        text = '一句。两句。'
+        self.assertEqual(reply_split.split_reply(text, dict(CFG, enabled=False)), [text])
+
+    def test_empty_text(self):
+        self.assertEqual(reply_split.split_reply('', CFG), [])
+
+    def test_single_sentence_not_split(self):
+        self.assertEqual(reply_split.split_reply('只有一句话。', CFG), ['只有一句话。'])
+
+    def test_plain_text_without_punctuation(self):
+        self.assertEqual(reply_split.split_reply('没有标点的句子', CFG), ['没有标点的句子'])
+
+    def test_invalid_mode_falls_back(self):
+        self.assertIn(reply_split.split_reply('甲。乙。丙。', {'enabled': True, 'mode': 'bogus', 'min_chars': 1}), [['甲。乙。丙。'], ['甲。', '乙。', '丙。']])
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_reply_split_astrbot.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+import re, unittest
+from biocore_model import reply_split
+
+BASE = {'enable': True, 'words_count_threshold': 150, 'split_mode': 'words',
+        'split_words': ['。', '？', '！'], 'content_cleanup_rule': ''}
+
+def astrbot_reference(text, cfg):
+    if not cfg.get('enable'): return [text]
+    if len(text) > cfg.get('words_count_threshold', 150): return [text]
+    if cfg.get('split_mode') == 'words':
+        out, buf = [], ''
+        for ch in text:
+            buf += ch
+            if any(buf.endswith(w) for w in cfg.get('split_words') or []):
+                out.append(buf); buf = ''
+        if buf.strip(): out.append(buf)
+    else:
+        out = re.findall(cfg.get('regex') or '[^\\n]+', text, re.DOTALL | re.MULTILINE)
+    cleanup = cfg.get('content_cleanup_rule') or ''
+    out = [re.sub(cleanup, '', p) if cleanup else p for p in out]
+    out = [p for p in out if str(p).strip()]
+    return out if len(out) >= 2 else [text]
+
+class AstrbotModeTest(unittest.TestCase):
+    def test_default_mode_is_astrbot(self):
+        self.assertEqual(reply_split.DEFAULTS['mode'], 'astrbot')
+    def test_disabled_returns_single(self):
+        cfg = dict(BASE, enable=False)
+        self.assertEqual(reply_split.split_reply('一句。两句。', {'enabled': True, 'astrbot': cfg, 'inject_newlines': False}), ['一句。两句。'])
+    def test_threshold_exceeded_not_split(self):
+        cfg = dict(BASE, words_count_threshold=5)
+        self.assertEqual(reply_split.split_reply('一句。两句。', {'enabled': True, 'astrbot': cfg, 'inject_newlines': False}), ['一句。两句。'])
+    def test_words_matches_astrbot_reference(self):
+        text = '第一句话。第二句话？第三句话！'
+        cfg = dict(BASE)
+        ours = reply_split.split_reply(text, {'enabled': True, 'astrbot': cfg, 'inject_newlines': False})
+        self.assertEqual(ours, astrbot_reference(text, cfg))
+    def test_regex_mode_newline(self):
+        text = '第一行\n第二行\n第三行'
+        cfg = {'enable': True, 'words_count_threshold': 150, 'split_mode': 'regex', 'regex': '[^\\n]+', 'content_cleanup_rule': ''}
+        self.assertEqual(reply_split.split_reply(text, {'enabled': True, 'astrbot': cfg, 'inject_newlines': False}), ['第一行', '第二行', '第三行'])
+    def test_regex_matches_astrbot_reference(self):
+        text = '甲\n乙\n丙'
+        cfg = {'enable': True, 'words_count_threshold': 150, 'split_mode': 'regex', 'regex': '[^\\n]+', 'content_cleanup_rule': ''}
+        self.assertEqual(reply_split.split_reply(text, {'enabled': True, 'astrbot': cfg, 'inject_newlines': False}), astrbot_reference(text, cfg))
+    def test_cleanup_rule_removes_content(self):
+        text = '第一句[cut]话。第二句[cut]话？'
+        cfg = {'enable': True, 'words_count_threshold': 150, 'split_mode': 'words', 'split_words': ['。', '？'], 'content_cleanup_rule': r'\[cut\]'}
+        parts = reply_split.split_reply(text, {'enabled': True, 'astrbot': cfg, 'inject_newlines': False})
+        self.assertEqual(parts, ['第一句话。', '第二句话？'])
+    def test_below_two_segments_returns_whole(self):
+        cfg = dict(BASE)
+        self.assertEqual(reply_split.split_reply('只有一句。', {'enabled': True, 'astrbot': cfg, 'inject_newlines': False}), ['只有一句。'])
+    def test_empty_text(self):
+        self.assertEqual(reply_split.split_reply('', {'enabled': True, 'astrbot': BASE, 'inject_newlines': False}), [])
+    def test_effective_shape(self):
+        eff = reply_split.effective(None)
+        for key in ('enable', 'threshold', 'mode', 'regex_or_words'):
+            self.assertIn(key, eff)
+    def test_read_astrbot_settings_defaults_no_crash(self):
+        settings = reply_split.read_astrbot_settings(None)
+        self.assertIn('split_mode', settings)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_reply_split_inject.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+import re, unittest
+from biocore_model import reply_split
+
+ENABLED = {'enable': True, 'words_count_threshold': 150, 'split_mode': 'regex', 'regex': '[^\\n]+'}
+
+class InjectNewlinesTest(unittest.TestCase):
+    def _inject(self, text, settings=None):
+        return reply_split.inject_sentence_newlines(text, settings or ENABLED)
+
+    def test_multi_sentence_one_per_line(self):
+        self.assertEqual(self._inject('第一句。第二句？第三句！'), '第一句。\n第二句？\n第三句！')
+
+    def test_punctuation_kept(self):
+        out = self._inject('甲。乙！')
+        self.assertTrue(out.endswith('甲。\n乙！'))
+
+    def test_existing_newline_not_duplicated(self):
+        self.assertEqual(self._inject('第一句。\n第二句。'), '第一句。\n第二句。')
+
+    def test_no_punctuation_unchanged(self):
+        self.assertEqual(self._inject('没有标点的句子'), '没有标点的句子')
+
+    def test_over_threshold_no_injection(self):
+        text = '一句。两句。'
+        self.assertEqual(self._inject(text, dict(ENABLED, words_count_threshold=5)), text)
+
+    def test_disabled_no_injection(self):
+        text = '一句。两句。'
+        self.assertEqual(self._inject(text, dict(ENABLED, enable=False)), text)
+
+    def test_single_sentence_unchanged(self):
+        self.assertEqual(self._inject('只有一句。'), '只有一句。')
+
+    def test_blank_lines_collapsed(self):
+        self.assertEqual(self._inject('甲。\n\n乙。'), '甲。\n乙。')
+
+    def test_astrbot_regex_splits_into_sentences(self):
+        text = self._inject('第一句。第二句？第三句！')
+        self.assertEqual(len(re.findall(r'[^\n]+', text, re.DOTALL | re.MULTILINE)), 3)
+
+    def test_split_reply_returns_single_text_with_newlines(self):
+        cfg = {'enabled': True, 'astrbot': ENABLED, 'inject_newlines': True}
+        parts = reply_split.split_reply('甲。乙。', cfg)
+        self.assertEqual(parts, ['甲。\n乙。'])
+
+    def test_status_has_inject_flag(self):
+        self.assertTrue(reply_split.status.__doc__ is not None)
+        class P: config = {}
+        self.assertTrue(reply_split.status(P())['inject_newlines'])
+
+if __name__ == '__main__':
+    unittest.main()