echotools 2.3.64__tar.gz → 2.3.66__tar.gz

{echotools-2.3.64 → echotools-2.3.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.3.64
+Version: 2.3.66
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Home-page: https://github.com/nichengfuben/echotools
 Author: nichengfuben

{echotools-2.3.64 → echotools-2.3.66}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "echotools"
-version = "2.3.64"
+version = "2.3.66"
 description = "通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链"
 readme = "docs/README.md"
 requires-python = ">=3.8"

{echotools-2.3.64 → echotools-2.3.66}/src/echotools/exec/fncall/parsers/stream.py

@@ -629,6 +629,9 @@ class FncallStreamParser:
 
         # 统一从「可见正文 + fncall 缓冲」解析，避免漏检；thinking 已在过滤器中剥离
         assembled = "".join(self._text_parts) + self._fncall_buf
+        from echotools.exec.fncall.shared.history_markup import strip_fake_history_markup
+
+        assembled, _ = strip_fake_history_markup(assembled)
         clean_text, tool_calls = self._protocol.parse(assembled, self._tools)
 
         clean_fn = getattr(self._protocol, "clean_tool_tags", None)

{echotools-2.3.64 → echotools-2.3.66}/src/echotools/exec/fncall/prompt/inject.py

@@ -29,6 +29,9 @@ from echotools.exec.fncall.protocols.entml_think.hist import (
     apply_thinking_history_policy,
     parse_include_thinking_in_history,
 )
+from echotools.exec.fncall.shared.history_markup import (
+    detect_fake_history_markup,
+)
 from echotools.exec.fncall.shared.loop_detect import detect_tool_loop
 from echotools.exec.fncall.shared.normalization import (
     format_tool_descs,
@@ -75,6 +78,11 @@ def build_tools_prompt(
         if result.is_looping:
             logger.debug("检测到工具循环（%d 次）", result.repeat_count)
             loop_warning = result.suggestion
+    history_markup_warning = ""
+    markup_result = detect_fake_history_markup(normalized)
+    if markup_result.detected:
+        logger.debug("检测到 assistant/tool 伪 history 标签")
+        history_markup_warning = markup_result.suggestion
     if hasattr(protocol, "format_tool_descs"):
         tool_descs = protocol.format_tool_descs(tools)
     else:
@@ -92,6 +100,7 @@ def build_tools_prompt(
         user_system_prompt=user_system_prompt,
         history_text=history_text,
         loop_warning=loop_warning,
+        history_markup_warning=history_markup_warning,
         current_user_message=current_user_message,
         **extra,
     )

{echotools-2.3.64 → echotools-2.3.66}/src/echotools/exec/fncall/protocols/entml.py

@@ -30,6 +30,7 @@ from echotools.exec.fncall.protocols.entml_think.core import (
     build_entml_thinking_section,
 )
 from echotools.exec.fncall.protocols.entml_tools import format_entml_tool_descs
+from echotools.exec.fncall.shared.history_markup import strip_fake_history_markup
 from echotools.exec.fncall.shared.coercion import _build_param_schema_index
 from echotools.exec.fncall.shared.normalization import (
     normalize_content,
@@ -176,6 +177,7 @@ class EntmlProtocol(ToolProtocol):
         user_system_prompt: str = "",
         history_text: str = "",
         loop_warning: str = "",
+        history_markup_warning: str = "",
         current_user_message: Optional[str] = None,
         protocol_options: Optional[Dict[str, Any]] = None,
         history_has_tool_calls: bool = False,
@@ -202,6 +204,11 @@ class EntmlProtocol(ToolProtocol):
         if loop_warning:
             sections.append(f"<loop_warning>\n{loop_warning}\n</loop_warning>")
 
+        if history_markup_warning:
+            sections.append(
+                f"<history_markup_warning>\n{history_markup_warning}\n</history_markup_warning>"
+            )
+
         if current_user_message is not None:
             sections.append(format_entml_current_user_message(current_user_message))
 
@@ -270,16 +277,21 @@ class EntmlProtocol(ToolProtocol):
 
         schema_index = _build_param_schema_index(tools) if tools else None
         parse_text, _thinking = split_entml_thinking(text, thinking_enabled=True)
-        if has_unclosed_entml_thinking(parse_text, thinking_enabled=True):
-            open_at, _ = _find_earliest_thinking_open(parse_text, thinking_enabled=True)
-            if open_at >= 0:
-                parse_text = parse_text[:open_at]
+        unclosed_open_at = -1
+        if has_unclosed_entml_thinking(text, thinking_enabled=True):
+            unclosed_open_at, _ = _find_earliest_thinking_open(
+                text, thinking_enabled=True
+            )
+            if unclosed_open_at >= 0:
+                parse_text = text[:unclosed_open_at]
+        parse_text, _ = strip_fake_history_markup(parse_text)
         tool_calls = parse_entml_tool_calls(parse_text, tools, schema_index)
-        clean = text
+        clean = text[:unclosed_open_at] if unclosed_open_at >= 0 else text
         if tool_calls:
-            clean = BLOCK_RE.sub("", text)
+            clean = BLOCK_RE.sub("", clean)
         # 无论是否解析成功，都剥离工具相关残留，避免标签泄露；thinking 保留给后续 split。
         clean = strip_tool_entml_residue(clean)
+        clean, _ = strip_fake_history_markup(clean)
         return (clean, normalize_tool_calls(tool_calls, tools))
 
     def parse_fragment(
@@ -294,8 +306,10 @@ class EntmlProtocol(ToolProtocol):
         return strip_entml_from_content(content)
 
     def clean_tool_tags(self, content: str) -> str:
-        """仅剥离工具相关标签残留，保留 thinking。"""
-        return strip_tool_entml_residue(content)
+        """仅剥离工具相关标签残留，保留 thinking；并移除伪 history 块。"""
+        cleaned = strip_tool_entml_residue(content)
+        cleaned, _ = strip_fake_history_markup(cleaned)
+        return cleaned
 
     def format_assistant_tool_calls(
         self,

echotools-2.3.66/src/echotools/exec/fncall/shared/history_markup.py

@@ -0,0 +1,135 @@
+"""检测并剥离模型误输出的 conversation history 伪标签（``<assistant>`` / ``<tool>``）。"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Tuple
+
+from echotools.exec.fncall.shared.normalization import normalize_content
+
+_FAKE_HISTORY_TAGS = ("assistant", "tool")
+_FAKE_MARKUP_BLOCK_DETECT_RE = re.compile(
+    r"(?:^|\n)\s*</?(?:assistant|tool)\s*>\s*(?:\n|$)",
+    re.IGNORECASE | re.MULTILINE,
+)
+_ENTML_THINKING_OPEN_RE = re.compile(
+    r"<entml:thinking\b[^>]*>",
+    re.IGNORECASE,
+)
+_ENTML_THINKING_CLOSE = "</entml:thinking>"
+
+
+class HistoryMarkupDetectionResult:
+    """伪 history 标签检测结果。"""
+
+    __slots__ = ("detected", "suggestion")
+
+    def __init__(self, detected: bool, suggestion: str = "") -> None:
+        self.detected = detected
+        self.suggestion = suggestion
+
+
+_HISTORY_MARKUP_SUGGESTION = (
+    "Do NOT output <assistant> or <tool> blocks in your reply. "
+    "Those tags are reserved for injected conversation history only. "
+    "Use <entml:thinking> for private reasoning and <entml:invoke> for tool calls. "
+    "Write visible replies as plain text without history markup."
+)
+
+
+def detect_fake_history_markup(
+    messages: List[Dict[str, Any]],
+) -> HistoryMarkupDetectionResult:
+    """扫描 assistant 正文是否误含块级 ``<assistant>`` / ``<tool>`` 伪标签。"""
+    for msg in messages:
+        if (msg.get("role") or "") != "assistant":
+            continue
+        content = normalize_content(msg.get("content", ""))
+        if content and _FAKE_MARKUP_BLOCK_DETECT_RE.search(content):
+            return HistoryMarkupDetectionResult(True, _HISTORY_MARKUP_SUGGESTION)
+    return HistoryMarkupDetectionResult(False, "")
+
+
+def _paired_block_re(tag: str) -> re.Pattern[str]:
+    return re.compile(
+        rf"(?:^|\n)\s*<{tag}\s*>\s*\n[\s\S]*?\n\s*</{tag}\s*>",
+        re.IGNORECASE,
+    )
+
+
+def _orphan_close_re(tag: str) -> re.Pattern[str]:
+    return re.compile(
+        rf"(?:^|\n)([\s\S]*?)\n\s*</{tag}\s*>\s*(?:\n|$)",
+        re.IGNORECASE,
+    )
+
+
+def _orphan_open_re(tag: str) -> re.Pattern[str]:
+    return re.compile(
+        rf"(?:^|\n)\s*<{tag}\s*>\s*\n[\s\S]*$",
+        re.IGNORECASE,
+    )
+
+
+def _strip_fake_blocks_in_segment(segment: str) -> Tuple[str, bool]:
+    if not segment:
+        return segment, False
+    found = False
+    text = segment
+    for tag in _FAKE_HISTORY_TAGS:
+        pair_re = _paired_block_re(tag)
+        while True:
+            new_text, n = pair_re.subn("", text, count=1)
+            if n == 0:
+                break
+            found = True
+            text = new_text
+        close_re = _orphan_close_re(tag)
+        while True:
+            new_text, n = close_re.subn("\n", text, count=1)
+            if n == 0:
+                break
+            found = True
+            text = new_text
+        open_re = _orphan_open_re(tag)
+        while True:
+            new_text, n = open_re.subn("", text, count=1)
+            if n == 0:
+                break
+            found = True
+            text = new_text
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text, found
+
+
+def strip_fake_history_markup(content: str) -> Tuple[str, bool]:
+    """剥离块级伪 ``<assistant>`` / ``<tool>``；``<entml:thinking>`` 区域原样保留。"""
+    if not content:
+        return content, False
+
+    parts: List[str] = []
+    found = False
+    i = 0
+    while i < len(content):
+        open_m = _ENTML_THINKING_OPEN_RE.search(content, i)
+        if not open_m:
+            chunk, hit = _strip_fake_blocks_in_segment(content[i:])
+            parts.append(chunk)
+            found = found or hit
+            break
+
+        if open_m.start() > i:
+            chunk, hit = _strip_fake_blocks_in_segment(content[i : open_m.start()])
+            parts.append(chunk)
+            found = found or hit
+
+        body_start = open_m.end()
+        close_at = content.find(_ENTML_THINKING_CLOSE, body_start)
+        if close_at >= 0:
+            parts.append(content[open_m.start() : close_at + len(_ENTML_THINKING_CLOSE)])
+            i = close_at + len(_ENTML_THINKING_CLOSE)
+        else:
+            parts.append(content[open_m.start() :])
+            break
+
+    return "".join(parts), found

{echotools-2.3.64 → echotools-2.3.66}/src/echotools/exec/protocol/base.py

@@ -49,6 +49,7 @@ class ToolProtocol(ABC):
         user_system_prompt: str = "",
         history_text: str = "",
         loop_warning: str = "",
+        history_markup_warning: str = "",
         current_user_message: Optional[str] = None,
         protocol_options: Optional[Dict[str, Any]] = None,
     ) -> str:

{echotools-2.3.64 → echotools-2.3.66}/src/echotools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.3.64
+Version: 2.3.66
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Home-page: https://github.com/nichengfuben/echotools
 Author: nichengfuben

{echotools-2.3.64 → echotools-2.3.66}/src/echotools.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ src/echotools/exec/fncall/protocols/entml_think/hist.py
 src/echotools/exec/fncall/protocols/entml_think/parse.py
 src/echotools/exec/fncall/shared/__init__.py
 src/echotools/exec/fncall/shared/coercion.py
+src/echotools/exec/fncall/shared/history_markup.py
 src/echotools/exec/fncall/shared/loop_detect.py
 src/echotools/exec/fncall/shared/normalization.py
 src/echotools/exec/fncall/shared/schema_render.py
@@ -198,8 +199,11 @@ src/tests/test_errors_common.py
 src/tests/test_events.py
 src/tests/test_events_event.py
 src/tests/test_facade.py
+src/tests/test_fault_thinking_close_batch.py
+src/tests/test_fault_thinking_close_stream.py
 src/tests/test_fncall.py
 src/tests/test_fncall_stream_thinking.py
+src/tests/test_history_markup_filter.py
 src/tests/test_ids.py
 src/tests/test_imports.py
 src/tests/test_io.py
@@ -223,4 +227,5 @@ src/tests/test_usage.py
 src/tests/test_web.py
 src/tests/test_web_broker.py
 src/tests/fixtures/__init__.py
+src/tests/fixtures/simulated_fault_thinking_responses.py
 src/tests/fixtures/simulated_llm_tool_responses.py

echotools-2.3.66/src/tests/fixtures/simulated_fault_thinking_responses.py

@@ -0,0 +1,220 @@
+"""模拟模型 ``<entml:thinking>…</thinking>`` fault 容错输出（rogator / Claude Code 高发）。
+
+非真实模型日志；用于 batch ``protocol.parse`` 与 ``FncallStreamParser`` 分流回归。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+from fixtures.simulated_llm_tool_responses import AGENT_TOOLS, TOOLS, _TOOL_BY_NAME
+
+
+@dataclass(frozen=True)
+class FaultThinkingCase:
+    """一条 fault ``</thinking>`` 模拟回复及 batch/stream 期望。"""
+
+    id: str
+    description: str
+    response: str
+    extra_tools: Tuple[str, ...] = ()
+    expect_names: Tuple[str, ...] = ()
+    expect_args: Tuple[Dict[str, Any], ...] = ()
+    expect_call_count: Optional[int] = None
+    expect_thinking_contains: Tuple[str, ...] = ()
+    expect_clean_contains: Tuple[str, ...] = ()
+    expect_clean_absent: Tuple[str, ...] = ("entml:invoke", "entml:parameter")
+    expect_clean_excludes: Tuple[str, ...] = ()
+    expect_split_thinking_contains: Tuple[str, ...] = ()
+    expect_split_thinking_empty: bool = False
+    chunk_sizes: Tuple[int, ...] = (1, 3, 5, 8, 17, 64)
+    worst_split: bool = False
+
+
+READ_TOOL: Dict[str, Any] = {
+    "type": "function",
+    "function": {
+        "name": "Read",
+        "parameters": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"],
+        },
+    },
+}
+
+_EXTRA_BY_NAME: Dict[str, Dict[str, Any]] = {
+    **_TOOL_BY_NAME,
+    "Read": READ_TOOL,
+}
+
+
+def tools_for_fault_case(case: FaultThinkingCase) -> List[Dict[str, Any]]:
+    names = {t["function"]["name"] for t in TOOLS}
+    out = list(TOOLS)
+    for name in case.extra_tools:
+        if name not in names and name in _EXTRA_BY_NAME:
+            out.append(_EXTRA_BY_NAME[name])
+            names.add(name)
+    return out
+
+
+def _big_bash_body() -> str:
+    script = "python -c \"print('ok')\"" + ";" + "echo " + ("x" * 6800)
+    return (
+        "<entml:thinking>\n"
+        "用户要求执行较长 shell；我先确认不会破坏环境，再用 Bash。\n"
+        "</thinking>\n"
+        '<entml:invoke name="Bash">\n'
+        f'<entml:parameter name="command">{script}</entml:parameter>\n'
+        "</entml:invoke>"
+    )
+
+
+FAULT_THINKING_CASES: Tuple[FaultThinkingCase, ...] = (
+    FaultThinkingCase(
+        id="model_fault_read_after_close",
+        description="rogator 高发：中文思考 + </thinking> + 说明 + Read",
+        extra_tools=("Read",),
+        response=(
+            "<entml:thinking>\n"
+            "用户希望查看 main.py。我先确认路径，再调用 Read。\n"
+            "</thinking>\n"
+            "我先读取该文件。\n"
+            '<entml:invoke name="Read">\n'
+            '<entml:parameter name="path">src/main.py</entml:parameter>\n'
+            "</entml:invoke>"
+        ),
+        expect_names=("Read",),
+        expect_args=({"path": "src/main.py"},),
+        expect_thinking_contains=("main.py", "Read"),
+        expect_clean_contains=("我先读取该文件。",),
+        expect_split_thinking_contains=("main.py",),
+        worst_split=True,
+    ),
+    FaultThinkingCase(
+        id="model_fault_bash_git_status",
+        description="英文思考 + </thinking> 后直接 Bash（无中间正文）",
+        extra_tools=("Bash",),
+        response=(
+            "<entml:thinking>\n"
+            "Need to inspect the working tree before answering.\n"
+            "</thinking>\n"
+            '<entml:invoke name="Bash">\n'
+            '<entml:parameter name="command">git status --short</entml:parameter>\n'
+            "</entml:invoke>"
+        ),
+        expect_names=("Bash",),
+        expect_args=({"command": "git status --short"},),
+        expect_thinking_contains=("working tree",),
+        expect_split_thinking_contains=("working tree",),
+    ),
+    FaultThinkingCase(
+        id="model_fault_weather_with_visible",
+        description="fault 闭合后先可见说明再 get_weather",
+        response=(
+            "<entml:thinking>\n"
+            "用户问杭州天气，我需要调用 get_weather。\n"
+            "</thinking>\n"
+            "正在查询杭州天气。\n"
+            '<entml:invoke name="get_weather">\n'
+            '<entml:parameter name="city">杭州</entml:parameter>\n'
+            '<entml:parameter name="unit">c</entml:parameter>\n'
+            "</entml:invoke>"
+        ),
+        expect_names=("get_weather",),
+        expect_args=({"city": "杭州", "unit": "c"},),
+        expect_thinking_contains=("杭州",),
+        expect_clean_contains=("正在查询杭州天气。",),
+        expect_split_thinking_contains=("杭州",),
+    ),
+    FaultThinkingCase(
+        id="model_fault_read_then_bash",
+        description="</thinking> 后连续 Read + Bash（双工具）",
+        extra_tools=("Read", "Bash"),
+        response=(
+            "<entml:thinking>\n"
+            "先读配置，再跑脚本验证。\n"
+            "</thinking>\n"
+            '<entml:invoke name="Read">\n'
+            '<entml:parameter name="path">config.toml</entml:parameter>\n'
+            "</entml:invoke>\n"
+            '<entml:invoke name="Bash">\n'
+            '<entml:parameter name="command">python verify.py</entml:parameter>\n'
+            "</entml:invoke>"
+        ),
+        expect_names=("Read", "Bash"),
+        expect_args=({"path": "config.toml"}, {"command": "python verify.py"}),
+        expect_thinking_contains=("先读配置",),
+        expect_split_thinking_contains=("先读配置",),
+    ),
+    FaultThinkingCase(
+        id="model_fault_close_without_invoke",
+        description="</thinking> 后无 invoke，直到标准 </entml:thinking> 才结束",
+        response=(
+            "<entml:thinking>\n"
+            "模型有时会在正文里提到 </thinking> 标签本身。\n"
+            "</thinking>\n"
+            "继续推理，尚未调用工具。\n"
+            "</entml:thinking>\n"
+            "这是给用户的最终回答。"
+        ),
+        expect_call_count=0,
+        expect_thinking_contains=("提到", "继续推理"),
+        expect_clean_contains=("最终回答",),
+        expect_split_thinking_contains=("</thinking>", "继续推理"),
+    ),
+    FaultThinkingCase(
+        id="model_invoke_inside_before_fault_close",
+        description="错误：invoke 写在 </thinking> 之前，不得解析",
+        extra_tools=("Bash",),
+        response=(
+            "<entml:thinking>\n"
+            "我先尝试调用 Bash：\n"
+            '<entml:invoke name="Bash">\n'
+            '<entml:parameter name="command">echo oops</entml:parameter>\n'
+            "</entml:invoke>\n"
+            "</thinking>\n"
+            "以上是思考过程，现在开始正式回复。"
+        ),
+        expect_call_count=0,
+        expect_thinking_contains=("echo oops", "正式回复"),
+        expect_clean_excludes=("正式回复", "echo oops"),
+        expect_split_thinking_empty=True,
+    ),
+    FaultThinkingCase(
+        id="model_fault_large_bash",
+        description="rogator 7KB 级 Bash：fault 闭合后长 parameter",
+        extra_tools=("Bash",),
+        response=_big_bash_body(),
+        expect_names=("Bash",),
+        expect_thinking_contains=("较长 shell",),
+        expect_split_thinking_contains=("较长 shell",),
+        chunk_sizes=(1, 8, 17, 64),
+    ),
+    FaultThinkingCase(
+        id="model_fault_multiline_parameter_read",
+        description="</thinking> 与 invoke/parameter 之间有额外空行",
+        extra_tools=("Read",),
+        response=(
+            "<entml:thinking>\n"
+            "Read C:/tmp/x.py\n"
+            "</thinking>\n"
+            "\n"
+            '<entml:invoke name="Read">\n'
+            '\n'
+            '<entml:parameter name="path">C:/tmp/x.py</entml:parameter>\n'
+            "\n"
+            "</entml:invoke>"
+        ),
+        expect_names=("Read",),
+        expect_args=({"path": "C:/tmp/x.py"},),
+        expect_thinking_contains=("Read C:/tmp/x.py",),
+        worst_split=True,
+    ),
+)
+
+
+def iter_fault_thinking_cases() -> List[FaultThinkingCase]:
+    return list(FAULT_THINKING_CASES)

{echotools-2.3.64 → echotools-2.3.66}/src/tests/fixtures/simulated_llm_tool_responses.py

@@ -578,7 +578,7 @@ SIMULATED_LLM_RESPONSES: List[SimulatedCase] = [
         ),
         expect_names=["get_weather"],
         expect_args=[{"city": "杭州", "unit": "c"}],
-        expect_clean_substrings=["参考历史：", '{get_weather: {"city": "杭州", "unit": "c"}', "我再确认一次实时天气。"],
+        expect_clean_substrings=["参考历史：", "我再确认一次实时天气。"],
     ),
     # --- 模型分支：Claude Code / rogator 常见 agent 工具 ---
     SimulatedCase(

echotools-2.3.66/src/tests/test_fault_thinking_close_batch.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+"""非流式：``<entml:thinking>…</thinking>`` fault 容错 — ``protocol.parse`` / ``split_entml_thinking``。"""
+
+import json
+from typing import Any, Dict, List
+
+import pytest
+
+from echotools.exec.fncall import get_protocol
+from echotools.exec.fncall.protocols.entml_think.parse import (
+    find_complete_entml_invoke_open,
+    has_unclosed_entml_thinking,
+    invoke_index_inside_unclosed_thinking,
+    split_entml_thinking,
+)
+from fixtures.simulated_fault_thinking_responses import (
+    FaultThinkingCase,
+    iter_fault_thinking_cases,
+    tools_for_fault_case,
+)
+
+CASES = iter_fault_thinking_cases()
+CASE_IDS = [c.id for c in CASES]
+
+
+def _names(calls: List[Dict[str, Any]]) -> List[str]:
+    return [c["function"]["name"] for c in calls]
+
+
+def _args(calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    return [json.loads(c["function"]["arguments"]) for c in calls]
+
+
+def _batch_parse(case: FaultThinkingCase) -> tuple[str, List[Dict[str, Any]]]:
+    return get_protocol("entml").parse(case.response, tools_for_fault_case(case))
+
+
+def _clean_needles(case: FaultThinkingCase) -> tuple[str, ...]:
+    return case.expect_clean_contains
+
+
+def _assert_clean(case: FaultThinkingCase, clean: str, *, label: str) -> None:
+    for needle in _clean_needles(case):
+        assert needle in clean, f"{case.id}/{label}: clean missing {needle!r}"
+    for bad in case.expect_clean_absent:
+        assert bad not in clean, f"{case.id}/{label}: clean leaked {bad!r}"
+    for bad in case.expect_clean_excludes:
+        assert bad not in clean, f"{case.id}/{label}: clean must exclude {bad!r}"
+
+
+@pytest.mark.parametrize("case", CASES, ids=CASE_IDS)
+def test_batch_tool_calls(case: FaultThinkingCase) -> None:
+    clean, calls = _batch_parse(case)
+    if case.expect_call_count is not None:
+        assert len(calls) == case.expect_call_count, case.id
+    if case.expect_names:
+        assert _names(calls) == list(case.expect_names), case.id
+    if case.expect_args:
+        assert _args(calls) == list(case.expect_args), case.id
+    _assert_clean(case, clean, label="batch")
+
+
+@pytest.mark.parametrize("case", CASES, ids=CASE_IDS)
+def test_batch_split_entml_thinking(case: FaultThinkingCase) -> None:
+    content, thinking = split_entml_thinking(case.response)
+    if case.expect_split_thinking_empty:
+        assert thinking == "", case.id
+        assert has_unclosed_entml_thinking(case.response), case.id
+        return
+    for needle in case.expect_split_thinking_contains:
+        assert needle in thinking, f"{case.id}: split missing {needle!r}"
+    if case.expect_names:
+        assert not has_unclosed_entml_thinking(case.response), case.id
+        assert not has_unclosed_entml_thinking(content), case.id
+
+
+@pytest.mark.parametrize("case", CASES, ids=CASE_IDS)
+def test_batch_invoke_not_inside_unclosed_thinking(case: FaultThinkingCase) -> None:
+    pos = find_complete_entml_invoke_open(case.response)
+    if case.expect_names:
+        assert pos >= 0, case.id
+        assert not invoke_index_inside_unclosed_thinking(case.response, pos), case.id
+    elif case.id == "model_invoke_inside_before_fault_close":
+        assert pos >= 0, case.id
+        assert invoke_index_inside_unclosed_thinking(case.response, pos), case.id