echotools 2.4.9__tar.gz → 2.4.10__tar.gz

{echotools-2.4.9 → echotools-2.4.10}/PKG-INFO

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

{echotools-2.4.9 → echotools-2.4.10}/pyproject.toml

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

{echotools-2.4.9 → echotools-2.4.10}/src/echotools/base/io/printstream.py

@@ -257,7 +257,7 @@ def _cleanup() -> None:
     try:
         _global_print_stream.flush_remaining()
         _global_print_stream.stop()
-    except Exception:
+    except BaseException:
         pass
 
 

{echotools-2.4.9 → echotools-2.4.10}/src/echotools/exec/fncall/parsers/stream_final.py

@@ -48,7 +48,10 @@ class StreamFinalMixin:
         return visible
 
     def _stream_partial_display_text(self) -> str:
-        """流式 ``partial_text``：在 invoke 起点前截断 raw，保留尾部 holdback 空白。"""
+        """流式 ``partial_text``：保留 invoke 之间的交错正文，仅截断未闭合 invoke 起点。
+
+        在 invoke 起点前截断 raw，保留尾部 holdback 空白。
+        """
         from echotools.exec.fncall.protocols.entml_think.parse import (
             clean_stream_partial_visible,
             split_entml_thinking,
@@ -61,17 +64,7 @@ class StreamFinalMixin:
         raw = self._raw_buf
         if not raw:
             return ""
-
-        cut = len(raw)
-        from echotools.exec.fncall.protocols.entml_patterns import (
-            find_actionable_entml_invoke_open,
-        )
-
-        invoke_pos = find_actionable_entml_invoke_open(
-            raw, known_names=self._get_known_tool_names()
-        )
-        if invoke_pos >= 0:
-            cut = min(cut, invoke_pos)
+        cut, saw_invoke = self._invoke_cutoff(raw)
         segment = raw[:cut]
 
         buf = stream_safe_visible_prefix(
@@ -80,18 +73,87 @@ class StreamFinalMixin:
         )
         if not buf:
             return ""
-        cleaned, _ = strip_fake_history_markup_for_display(buf)
         visible, _ = split_entml_thinking(
-            cleaned,
+            buf,
             thinking_enabled=self._thinking_enabled,
             preserve_visible_whitespace=True,
         )
+        # 与 stream_safe 无未闭合 thinking 的 split 分支对齐：剥前导空白，
+        # 避免 thinking 打开/闭合瞬间 partial_text 首部 \n 抖动导致增量错位
+        visible = visible.lstrip()
+        visible = self._strip_completed_invoke_blocks(visible)
+        cleaned, _ = strip_fake_history_markup_for_display(visible)
+        if saw_invoke:
+            # invoke 前缀（<entml:...）被剥除后可能留下尾部换行；统一剥掉，
+            # 否则 invoke 开标签收齐瞬间 rstrip 翻转导致长度回退。空格保留
+            cleaned = cleaned.rstrip("\n\r")
         return clean_stream_partial_visible(
-            visible,
+            cleaned,
             has_calls=self.has_calls,
             thinking_enabled=self._thinking_enabled,
         )
 
+    def _invoke_cutoff(self, raw: str) -> Tuple[int, bool]:
+        """返回 ``(截断点, 是否出现 invoke 前缀)``。
+
+        截断到最后一个「打开但未闭合」的 invoke 起点：其后内容可能是参数，
+        不能进入 partial_text；已闭合 invoke 之间的正文保留。
+        """
+        from echotools.exec.fncall.protocols.entml_patterns.invoke import (
+            _find_matching_close,
+        )
+
+        cut = len(raw)
+        # `<entml:` 前缀即按 invoke 区域处理：前缀被剥除后留下的尾部换行
+        # 需统一剥掉，否则 invoke 开标签收齐瞬间 rstrip 翻转导致长度回退
+        saw_invoke = "<entml:" in raw
+        search_from = 0
+        while True:
+            open_pos = raw.find("<entml:invoke", search_from)
+            if open_pos < 0:
+                break
+            if not self._is_actionable_invoke_open(raw, open_pos):
+                gt = raw.find(">", open_pos + len("<entml:invoke"))
+                search_from = (gt + 1) if gt >= 0 else (open_pos + len("<entml:invoke"))
+                continue
+            gt = raw.find(">", open_pos + len("<entml:invoke"))
+            if gt < 0:
+                cut = min(cut, open_pos)
+                break
+            close = _find_matching_close(raw, gt + 1, "</entml:invoke>")
+            if close < 0:
+                cut = min(cut, open_pos)
+                break
+            search_from = close + len("</entml:invoke>")
+        return cut, saw_invoke
+
+    def _strip_completed_invoke_blocks(self, visible: str) -> str:
+        """已闭合 invoke 块整体移除（含参数），避免标签剥离后参数文本泄漏。"""
+        from echotools.exec.fncall.protocols.entml_patterns import (
+            iter_actionable_entml_invoke_blocks,
+            resolve_known_tool_names,
+        )
+
+        known = resolve_known_tool_names(self._tools, self._get_schema_index())
+        removed: List[str] = []
+        last_end = 0
+        for start, end, _attrs, _body in iter_actionable_entml_invoke_blocks(
+            visible, known_names=known
+        ):
+            removed.append(visible[last_end:start])
+            last_end = end
+        removed.append(visible[last_end:])
+        return "".join(removed)
+
+    def _is_actionable_invoke_open(self, raw: str, pos: int) -> bool:
+        from echotools.exec.fncall.protocols.entml_patterns import (
+            entml_invoke_open_is_actionable,
+        )
+
+        return entml_invoke_open_is_actionable(
+            raw, pos, known_names=self._get_known_tool_names()
+        )
+
     def _finalize_display_text(self, clean_text: str) -> str:
         if not self._thinking_enabled:
             return clean_text

{echotools-2.4.9 → echotools-2.4.10}/src/echotools/exec/fncall/protocols/entml_patterns/invoke.py

@@ -7,6 +7,54 @@ from .params import extract_attr_value, normalize_entml_name
 from .regex import _INVOKE_CLOSE, _INVOKE_OPEN_PREFIX
 
 
+# 参数体是 opaque 文本：内部可能包含字面量 ``</entml:invoke>`` 或
+# ``</entml:thinking>``（如 Python 正则字符串）。找闭合标签时须跳过参数体。
+_SKIP_PARAM_BODIES: List[Tuple[str, str]] = [
+    ("<entml:parameter", "</entml:parameter>"),
+    ("<entml:parameters>", "</entml:parameters>"),
+    ("<entml:parameter>", "</entml:parameter>"),
+]
+
+
+def _find_matching_close(
+    body: str,
+    start: int,
+    close_tag: str,
+) -> int:
+    """从 ``start`` 起找 ``close_tag``，跳过 ``<entml:parameter[...]>`` 体的内容。
+
+    参数体内部的字面量 ``</entml:invoke>`` / ``</entml:thinking>`` 是内容不是结构，
+    不能当作外层块的闭合。
+    """
+    i = start
+    n = len(body)
+    while i < n:
+        lt = body.find("<", i)
+        if lt < 0:
+            return -1
+        gt = body.find(">", lt)
+        if gt < 0:
+            return -1
+        tag = body[lt : gt + 1]
+        if tag == close_tag:
+            return lt
+        # 精确匹配 parameter 开标签（含属性的形式）；不匹配 siblings
+        if tag == "<entml:parameter>" or tag.startswith("<entml:parameter "):
+            close_pos = body.find("</entml:parameter>", gt)
+            if close_pos < 0:
+                return -1
+            i = close_pos + len("</entml:parameter>")
+            continue
+        if tag == "<entml:parameters>":
+            close_pos = body.find("</entml:parameters>", gt)
+            if close_pos < 0:
+                return -1
+            i = close_pos + len("</entml:parameters>")
+            continue
+        i = gt + 1
+    return -1
+
+
 def is_placeholder_invoke_name(name: str) -> bool:
     """提示词占位符（如 ``$FUNCTION_NAME``）不算真实工具调用。"""
     n = (name or "").strip()
@@ -158,7 +206,7 @@ def iter_actionable_entml_invoke_blocks(
         gt = text.find(">", pos + prefix_len)
         if gt < 0:
             break
-        close = text.find(_INVOKE_CLOSE, gt + 1)
+        close = _find_matching_close(text, gt + 1, _INVOKE_CLOSE)
         if close < 0:
             break
         attrs = text[pos + prefix_len : gt]
@@ -189,8 +237,11 @@ def _strip_orphan_invoke_tags(
 
 
 def _strip_orphan_non_invoke_tool_tags(content: str) -> str:
+    # 剥离 invoke 块外部的畸形 entml:* 标签（如模型把参数名输出成
+    # <entml:old_string">），仅保留 invoke/thinking 相关；prose 提及的
+    # <entml:invoke> 与未知工具块不在此列，留给调用方按 known 判定。
     return re.sub(
-        r"</?entml:(?:function_calls|parameter|parameters)\b[^>]*/?>",
+        r"</?entml:(?!invoke\b|thinking(?:_mode)?\b|max_thinking_length\b)\w+\b[^>]*/?>",
         "",
         content,
         flags=re.DOTALL,

{echotools-2.4.9 → echotools-2.4.10}/src/echotools/exec/fncall/protocols/entml_think/hold.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import List, Optional, Set, Tuple
+from typing import Callable, List, Optional, Set, Tuple
 
 from echotools.exec.fncall.protocols.entml_patterns import (
     entml_invoke_open_may_be_streaming,
@@ -84,15 +84,19 @@ def _find_thinking_close(
     thinking_enabled: bool = True,
 ) -> Tuple[int, int]:
     """返回 ``(闭标签下标, 闭标签长度)``；未找到则 ``(-1, 0)``。"""
+    from echotools.exec.fncall.protocols.entml_patterns.invoke import (
+        _find_matching_close,
+    )
+
     if not thinking_enabled:
-        close_at = text.find(_THINKING_CLOSE, body_start)
-        if close_at >= 0:
-            return close_at, len(_THINKING_CLOSE)
+        entml_close = _find_matching_close(text, body_start, _THINKING_CLOSE)
+        if entml_close >= 0:
+            return entml_close, len(_THINKING_CLOSE)
         return -1, 0
 
+    entml_close = _find_matching_close(text, body_start, _THINKING_CLOSE)
+    fault_close = _find_matching_close(text, body_start, _FAULT_THINKING_CLOSE)
     if opened_plain:
-        entml_close = text.find(_THINKING_CLOSE, body_start)
-        fault_close = text.find(_FAULT_THINKING_CLOSE, body_start)
         candidates: List[Tuple[int, int]] = []
         if entml_close >= 0:
             candidates.append((entml_close, len(_THINKING_CLOSE)))
@@ -100,11 +104,8 @@ def _find_thinking_close(
             candidates.append((fault_close, len(_FAULT_THINKING_CLOSE)))
         if not candidates:
             return -1, 0
-        close_at, close_len = min(candidates, key=lambda item: item[0])
-        return close_at, close_len
+        return min(candidates, key=lambda item: item[0])
 
-    entml_close = text.find(_THINKING_CLOSE, body_start)
-    fault_close = text.find(_FAULT_THINKING_CLOSE, body_start)
     if entml_close >= 0 and (fault_close < 0 or entml_close <= fault_close):
         return entml_close, len(_THINKING_CLOSE)
     if fault_close < 0:
@@ -112,7 +113,7 @@ def _find_thinking_close(
 
     after_fault = fault_close + len(_FAULT_THINKING_CLOSE)
     invoke_rel = find_complete_entml_invoke_open(text[after_fault:])
-    entml_after = text.find(_THINKING_CLOSE, after_fault)
+    entml_after = _find_matching_close(text, after_fault, _THINKING_CLOSE)
     if invoke_rel >= 0:
         invoke_abs = after_fault + invoke_rel
         if entml_after < 0 or invoke_abs < entml_after:
@@ -174,41 +175,90 @@ def _hold_ambiguous_tool_markup(
     return buffer, ""
 
 
-def _find_plain_thinking_open(text: str, start: int = 0) -> int:
-    """返回 plain ``<thinking>`` 开标签起始下标（``<entml:thinking>`` 内不含此子串）。"""
-    return text.find(_PLAIN_THINKING_OPEN_PREFIX, start)
-
 def _find_earliest_thinking_open(
     text: str,
     start: int = 0,
     *,
     thinking_enabled: bool = True,
 ) -> Tuple[int, bool]:
-    """返回 ``(开标签下标, 是否 plain)``；无则 ``(-1, False)``。"""
-    entml_at = text.find(_THINKING_OPEN_PREFIX, start)
-    if not thinking_enabled:
-        if entml_at < 0:
+    """返回 ``(开标签下标, 是否 plain)``；无则 ``(-1, False)``。
+
+    按标签逐段扫描，跳过 ``<entml:parameter>`` / ``<entml:parameters>`` 体——
+    参数值内可能含 ``<entml:thinking\\b[^>]*>`` 这类字面量（正则字符串），
+    不能当作真实 thinking 块。
+    """
+    from echotools.exec.fncall.protocols.entml_patterns.invoke import (
+        _find_matching_close,
+    )
+
+    def _skip_param_body(close_tag: str) -> Optional[int]:
+        pos = _find_matching_close(text, gt + 1, close_tag)
+        return pos + len(close_tag) if pos >= 0 else None
+
+    i = start
+    n = len(text)
+    while i < n:
+        lt = text.find("<", i)
+        if lt < 0:
             return -1, False
-        return entml_at, False
-    plain_at = _find_plain_thinking_open(text, start)
-    if entml_at < 0 and plain_at < 0:
-        return -1, False
-    if entml_at < 0:
-        return plain_at, True
-    if plain_at < 0:
-        return entml_at, False
-    if plain_at < entml_at:
-        return plain_at, True
-    return entml_at, False
+        gt = text.find(">", lt)
+        if gt < 0:
+            return _partial_open_check(text, lt, thinking_enabled)
+        tag = text[lt : gt + 1]
+        i = _advance_past_param_body(tag, gt, _skip_param_body)
+        if i is not None:
+            continue
+        if tag == (_THINKING_OPEN_PREFIX + ">") or tag.startswith(
+            _THINKING_OPEN_PREFIX + " "
+        ):
+            return lt, False
+        if thinking_enabled and _is_plain_thinking_open(tag):
+            return lt, True
+        i = gt + 1
+    return -1, False
 
-def has_unclosed_entml_thinking(
+
+def _partial_open_check(text: str, lt: int, thinking_enabled: bool) -> Tuple[int, bool]:
+    """处理未收齐的 ``<...`` 前缀：若是 thinking 开标签真前缀则视其为未闭合块。"""
+    partial = text[lt:]
+    if partial.startswith(_THINKING_OPEN_PREFIX):
+        return lt, False
+    if thinking_enabled and (
+        partial.startswith(_PLAIN_THINKING_OPEN_PREFIX)
+        and not partial.startswith(_THINKING_OPEN_PREFIX)
+    ):
+        return lt, True
+    return -1, False
+
+
+def _is_plain_thinking_open(tag: str) -> bool:
+    """``tag`` 是否为 plain ``<thinking...>``（不含 ``<entml:thinking`` 前缀）。"""
+    return tag.startswith(_PLAIN_THINKING_OPEN_PREFIX) and not tag.startswith(
+        _THINKING_OPEN_PREFIX
+    )
+
+
+def _advance_past_param_body(
+    tag: str,
+    gt: int,
+    skip_fn: "Callable[[str], Optional[int]]",
+) -> Optional[int]:
+    """若是 ``<entml:parameter[...]>`` / ``<entml:parameters>``，返回体闭合标签后的下标。"""
+    if tag.startswith("<entml:parameter"):
+        return skip_fn("</entml:parameter>")
+    if tag == "<entml:parameters>":
+        return skip_fn("</entml:parameters>")
+    return None
+
+
+def first_unclosed_thinking_open(
     text: str,
     *,
     thinking_enabled: bool = True,
-) -> bool:
-    """buffer 中是否存在尚未闭合的 thinking 块（含开标签未收齐）。"""
+) -> int:
+    """返回第一个未闭合 thinking 块的开标签下标；无则 ``-1``。"""
     if not text:
-        return False
+        return -1
     i = 0
     while i < len(text):
         open_at, opened_plain = _find_earliest_thinking_open(
@@ -218,7 +268,7 @@ def has_unclosed_entml_thinking(
             break
         gt = text.find(">", open_at)
         if gt < 0:
-            return True
+            return open_at
         body_start = gt + 1
         close_at, close_len = _find_thinking_close(
             text,
@@ -227,7 +277,7 @@ def has_unclosed_entml_thinking(
             thinking_enabled=thinking_enabled,
         )
         if close_at < 0:
-            return True
+            return open_at
         i = close_at + close_len
     max_keep = len(_THINKING_OPEN_PREFIX) - 1
     if thinking_enabled:
@@ -241,13 +291,24 @@ def has_unclosed_entml_thinking(
         ):
             if any(other.startswith(suffix) for other in _AMBIGUOUS_ENTML_PREFIXES):
                 continue
-            return True
+            return len(text) - length
         if thinking_enabled and (
             _PLAIN_THINKING_OPEN_PREFIX.startswith(suffix)
             and suffix != _PLAIN_THINKING_OPEN_PREFIX
         ):
-            return True
-    return False
+            return len(text) - length
+    return -1
+
+
+def has_unclosed_entml_thinking(
+    text: str,
+    *,
+    thinking_enabled: bool = True,
+) -> bool:
+    """buffer 中是否存在尚未闭合的 thinking 块（含开标签未收齐）。"""
+    return first_unclosed_thinking_open(
+        text, thinking_enabled=thinking_enabled
+    ) >= 0
 
 
 def invoke_index_inside_unclosed_thinking(

{echotools-2.4.9 → echotools-2.4.10}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -44,6 +44,7 @@ from echotools.exec.fncall.protocols.entml_think.hold import (
     _find_earliest_thinking_open,
     _find_thinking_close,
     find_complete_entml_invoke_open,
+    first_unclosed_thinking_open,
     has_unclosed_entml_thinking,
     invoke_index_inside_any_thinking_block,
     invoke_index_inside_unclosed_thinking,
@@ -71,6 +72,8 @@ def leading_entml_tag_holdback_len(
     if comment_hold:
         return comment_hold
     prefixes: List[str] = list(_LEADING_HOLD_PREFIXES)
+    # 流式分片可能把伪 history 闭标签切成真前缀，同样需要 hold
+    prefixes.extend(("</assistant", "</tool"))
     if thinking_enabled:
         prefixes.append(_PLAIN_THINKING_OPEN_PREFIX)
     for prefix in prefixes:
@@ -97,7 +100,8 @@ def stream_safe_visible_prefix(
         return ""
     buf = text[hold:]
     if has_unclosed_entml_thinking(buf, thinking_enabled=thinking_enabled):
-        open_at, _ = _find_earliest_thinking_open(
+        # 取第一个未闭合 thinking 块之前的内容；此前已闭合的 thinking 不应截断（交错场景）
+        open_at = first_unclosed_thinking_open(
             buf, thinking_enabled=thinking_enabled
         )
         if open_at >= 0:
@@ -128,6 +132,8 @@ def trailing_entml_tag_holdback_len(text: str) -> int:
     candidates: List[str] = list(_LEADING_HOLD_PREFIXES) + [
         _THINKING_CLOSE,
         _FAULT_THINKING_CLOSE,
+        "</assistant",
+        "</tool",
     ]
     for tag in candidates:
         if tag.startswith(tail) and tail != tag:
@@ -177,6 +183,9 @@ def clean_stream_partial_visible(
     tail_hold = trailing_entml_tag_holdback_len(text)
     if tail_hold:
         text = text[:-tail_hold]
+        # 剥掉未收齐标签后统一去尾部换行空白：否则标签补全瞬间长度回退，
+        # 流式增量（按长度推进）会错位。不剥空格——词尾空格是正文的一部分
+        text = text.rstrip("\n\r")
     text = strip_fake_entml_structure_markup_for_display(text)[0]
     if has_calls:
         text = text.rstrip()
@@ -239,7 +248,7 @@ def split_entml_thinking(
         clean_parts.append(text[i:open_at])
         gt = text.find(">", open_at)
         if gt < 0:
-            clean_parts.append(text[open_at:])
+            # 半开标签（未收齐）——不进 content，只保留其前可见
             break
         body_start = gt + 1
         close_at, close_len = _find_thinking_close(
@@ -249,7 +258,8 @@ def split_entml_thinking(
             thinking_enabled=thinking_enabled,
         )
         if close_at < 0:
-            clean_parts.append(text[open_at:])
+            # thinking 开标签完整但未闭合——其内容保留为可见（内含的 invoke 仍可解析）
+            clean_parts.append(text[body_start:])
             break
         parts.append(text[body_start:close_at])
         i = _advance_past_fault_thinking_close(

{echotools-2.4.9 → echotools-2.4.10}/src/echotools/exec/fncall/protocols/entml_tool/invoke.py

@@ -120,7 +120,13 @@ def parse_invoke_args(
 ) -> Dict[str, Any]:
     func_props = (schema_index or {}).get(name) or {}
     if "</entml:invoke>" in body:
-        body = body[: body.index("</entml:invoke>")]
+        # 参数体内可能含字面量 ``</entml:invoke>``（如 Python 正则字符串），
+        # 不能直接截断；用 tag-aware 查找器定位真实闭合（找不到才截断）。
+        from ..entml_patterns.invoke import _find_matching_close
+
+        real_close = _find_matching_close(body, 0, "</entml:invoke>")
+        if real_close >= 0:
+            body = body[:real_close]
     body = synthetic_close_invoke_body(body)
     params_m = PARAMETERS_RE.search(body)
     if params_m:

{echotools-2.4.9 → echotools-2.4.10}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.4.9 → echotools-2.4.10}/src/echotools.egg-info/SOURCES.txt

@@ -231,6 +231,7 @@ src/tests/test_entml_bare_invoke_format.py
 src/tests/test_entml_batch_stream_comprehensive.py
 src/tests/test_entml_fake_structure_markup.py
 src/tests/test_entml_golden.py
+src/tests/test_entml_interleaved_corpus.py
 src/tests/test_entml_invoke_known_tool_gate.py
 src/tests/test_entml_parser_comprehensive.py
 src/tests/test_entml_protocol.py
@@ -285,6 +286,7 @@ src/tests/test_web_broker.py
 src/tests/fixtures/__init__.py
 src/tests/fixtures/entml_golden.py
 src/tests/fixtures/entml_golden_update.py
+src/tests/fixtures/interleaved_corpus.py
 src/tests/fixtures/simulated_fake_history_markup_responses.py
 src/tests/fixtures/simulated_fault_thinking_responses.py
 src/tests/fixtures/simulated_llm_tool_responses.py

echotools-2.4.10/src/tests/fixtures/interleaved_corpus.py

@@ -0,0 +1,116 @@
+"""交错 thinking / invoke / 正文 回归语料。
+
+结构提炼自 Rogator 日志 `X:\\Project\\Public\\Rogator\\logs\\responses\\req-1787237525-7f1478678d5b.txt`：
+多轮 ``<entml:thinking>`` → 正文 → ``<entml:invoke>`` 交错出现，
+invoke 之间及 invoke 之后继续有正文与思考，最后以纯正文结尾。
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+INTERLEAVED_TOOLS: List[Dict[str, Any]] = [
+    {
+        "type": "function",
+        "function": {
+            "name": "Edit",
+            "description": "编辑文件",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string"},
+                    "old_string": {"type": "string"},
+                    "new_string": {"type": "string"},
+                },
+                "required": ["file_path", "old_string", "new_string"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "Read",
+            "description": "读取文件",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string"},
+                    "offset": {"type": "integer"},
+                    "limit": {"type": "integer"},
+                },
+                "required": ["file_path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "Bash",
+            "description": "运行命令",
+            "parameters": {
+                "type": "object",
+                "properties": {"command": {"type": "string"}},
+                "required": ["command"],
+            },
+        },
+    },
+]
+
+INTERLEAVED_CORPUS = """<entml:thinking>
+第一轮思考：需要先定位现有实现。
+</entml:thinking>
+
+第一轮正文：我先看看当前实现。
+
+<entml:invoke name="Edit">
+<entml:parameter name="file_path">src/config.py</entml:parameter>
+<entml:parameter name="old_string">old value</entml:parameter>
+<entml:parameter name="new_string">new value</entml:parameter>
+</entml:invoke>
+</assistant>
+
+<entml:thinking>
+第二轮思考：Edit 完成，继续检查调用点。
+</entml:thinking>
+
+第二轮正文：继续修复第二个位置。
+
+<entml:invoke name="Read">
+<entml:parameter name="file_path">src/config.py</entml:parameter>
+<entml:parameter name="offset">10</entml:parameter>
+<entml:parameter name="limit">25</entml:parameter>
+</entml:invoke>
+</assistant>
+
+<entml:thinking>
+第三轮思考：调用点确认，最后运行测试。
+</entml:thinking>
+
+第三轮正文：修改完成，运行验证。
+
+<entml:invoke name="Bash">
+<entml:parameter name="command">python -m pytest -q</entml:parameter>
+</entml:invoke>
+<entml:invoke name="Bash">
+<entml:parameter name="command">python achecker.py</entml:parameter>
+</entml:invoke>
+</assistant>
+
+全部通过，修复完成。
+
+"""
+
+EXPECT_NAMES = ["Edit", "Read", "Bash", "Bash"]
+
+EXPECT_VISIBLE_SEGMENTS = [
+    "第一轮正文：我先看看当前实现。",
+    "第二轮正文：继续修复第二个位置。",
+    "第三轮正文：修改完成，运行验证。",
+    "全部通过，修复完成。",
+]
+
+EXPECT_THINKING_MARKS = [
+    "第一轮思考：需要先定位现有实现。",
+    "第二轮思考：Edit 完成，继续检查调用点。",
+    "第三轮思考：调用点确认，最后运行测试。",
+]