echotools 2.3.84__tar.gz → 2.3.86__tar.gz

{echotools-2.3.84 → echotools-2.3.86}/PKG-INFO

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

{echotools-2.3.84 → echotools-2.3.86}/pyproject.toml

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

{echotools-2.3.84 → echotools-2.3.86}/src/echotools/exec/fncall/parsers/stream.py

@@ -273,6 +273,15 @@ class FncallStreamParser:
             self._waiting_tail = remain
             return
 
+        from echotools.exec.fncall.protocols.entml_think.parse import (
+            invoke_index_inside_any_thinking_block,
+        )
+        if invoke_index_inside_any_thinking_block(
+            text, pos, thinking_enabled=self._thinking_enabled,
+        ):
+            self._append_content_text(text)
+            return
+
         if pos > 0:
             self._append_content_text(text[:pos])
 
@@ -319,10 +328,10 @@ class FncallStreamParser:
         if found:
             if self._thinking_filter is not None:
                 from echotools.exec.fncall.protocols.entml_think.parse import (
-                    invoke_index_inside_unclosed_thinking,
+                    invoke_index_inside_any_thinking_block,
                 )
-                if invoke_index_inside_unclosed_thinking(
-                    combined, pos, thinking_enabled=self._thinking_enabled
+                if invoke_index_inside_any_thinking_block(
+                    combined, pos, thinking_enabled=self._thinking_enabled,
                 ):
                     self._feed_waiting_thinking_plain(combined)
                     return
@@ -750,6 +759,11 @@ class FncallStreamParser:
                 split_entml_thinking,
             )
 
+            _, batch_thinking = split_entml_thinking(
+                self._raw_buf, thinking_enabled=self._thinking_enabled
+            )
+            if batch_thinking:
+                self._thinking_parts = [batch_thinking]
             display_text, _ = split_entml_thinking(
                 clean_text, thinking_enabled=self._thinking_enabled
             )

{echotools-2.3.84 → echotools-2.3.86}/src/echotools/exec/fncall/protocols/entml.py

@@ -42,26 +42,15 @@ from echotools.exec.fncall.shared.normalization import (
 )
 from echotools.exec.protocol.base import ToolProtocol
 
-# 仅按 entml: 前缀剥离标签，不区分具体标签名。
-_ENTML_PAIR_RE = re.compile(
-    r"<entml:[a-zA-Z_][\w]*\b[^>]*>.*?</entml:[a-zA-Z_][\w]*>",
-    re.DOTALL,
-)
-_ENTML_SELF_CLOSING_RE = re.compile(r"<entml:[a-zA-Z_][\w]*\b[^>]*/>", re.DOTALL)
-_ENTML_ORPHAN_CLOSE_RE = re.compile(r"</entml:[a-zA-Z_][\w]*>", re.DOTALL)
-_ENTML_ORPHAN_OPEN_RE = re.compile(r"<entml:[a-zA-Z_][\w]*\b[^>]*>", re.DOTALL)
+# user 消息：仅去掉标签名中的 entml: 命名空间，保留标签与正文。
+_ENTML_NAMESPACE_RE = re.compile(r"(</?)entml:", re.IGNORECASE)
 
 
 def strip_entml_from_content(content: str) -> str:
-    """从 user 消息正文剥离所有 entml:* 标签及残留开闭标签。"""
+    """user 消息：去掉 ``entml:`` 标签前缀，保留标签结构与正文（含 ``//``）。"""
     if not content:
         return content
-    cleaned = content
-    cleaned = _ENTML_PAIR_RE.sub("", cleaned)
-    cleaned = _ENTML_SELF_CLOSING_RE.sub("", cleaned)
-    cleaned = _ENTML_ORPHAN_CLOSE_RE.sub("", cleaned)
-    cleaned = _ENTML_ORPHAN_OPEN_RE.sub("", cleaned)
-    return cleaned.strip()
+    return _ENTML_NAMESPACE_RE.sub(r"\1", content)
 
 
 def _parse_tool_call_args(tc: Dict[str, Any]) -> tuple[str, Dict[str, Any]]:
@@ -321,6 +310,7 @@ class EntmlProtocol(ToolProtocol):
         return tool_calls
 
     def clean_tags(self, content: str) -> str:
+        """user 消息：仅去掉 ``entml:`` 前缀，不做其它剥离。"""
         return strip_entml_from_content(content)
 
     def clean_tool_tags(self, content: str) -> str:

{echotools-2.3.84 → echotools-2.3.86}/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -51,7 +51,7 @@ PARAMETERS_RE = re.compile(
     r"<entml:parameters>([\s\S]*?)</entml:parameters>",
     re.DOTALL,
 )
-# invoke 内裸子标签（非 parameter 包裹），如 Claude Code 输出的 description/timeout。
+# invoke 内裸子标签（非 parameter 包裹），如部分 agent 输出的 description/timeout。
 BARE_INVOKE_CHILD_RE = re.compile(
     r"<entml:(description|timeout)>([\s\S]*?)</entml:\1>",
     re.DOTALL | re.IGNORECASE,

{echotools-2.3.84 → echotools-2.3.86}/src/echotools/exec/fncall/protocols/entml_stream_json.py

@@ -42,6 +42,19 @@ def _strip_incomplete_markup_suffix(value: str) -> str:
     return value
 
 
+def _strip_incomplete_child_close_suffix(value: str, key: str) -> str:
+    """流式未闭合 bare/direct 子标签：去掉尾部尚未收齐的 ``</...>``。"""
+    value = _strip_incomplete_markup_suffix(value)
+    lt = value.rfind("<")
+    if lt < 0:
+        return value
+    tail = value[lt:]
+    for close in (f"</entml:{key}>", f"</{key}>"):
+        if close.startswith(tail) and tail != close:
+            return value[:lt]
+    return value
+
+
 def split_invoke_open(buffer: str) -> Optional[Tuple[str, int]]:
     """返回当前正在流式写入的 invoke（最后一个有效开标签）。"""
     search_from = 0
@@ -177,6 +190,7 @@ def _parse_bare_invoke_entries(body: str) -> List[Tuple[str, str, bool, Optional
         tail = match.group(2) or ""
         if close in tail:
             continue
+        tail = _strip_incomplete_child_close_suffix(tail, key)
         tagged.append((match.start(), key, tail, False, None))
     tagged.sort(key=lambda item: item[0])
     seen: set[str] = set()
@@ -236,6 +250,7 @@ def _parse_direct_child_entries(body: str) -> List[Tuple[str, str, bool, Optiona
         tail = match.group(2) or ""
         if close in tail:
             continue
+        tail = _strip_incomplete_child_close_suffix(tail, key)
         tagged.append((match.start(), key, tail, False, None))
     tagged.sort(key=lambda item: item[0])
     seen: set[str] = set()

{echotools-2.3.84 → echotools-2.3.86}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -210,6 +210,19 @@ def _find_earliest_thinking_open(
     return entml_at, False
 
 
+def tool_markup_follows_entml_thinking_close(text: str) -> bool:
+    """``</entml:thinking>`` 后若紧跟真实工具 markup，则 fault ``</thinking>`` 与 entml 闭标签间为可见正文。"""
+    if not text:
+        return False
+    return bool(
+        re.search(
+            r"^\s*(?:<tool\s*>|<entml:invoke\b)",
+            text,
+            re.IGNORECASE | re.DOTALL,
+        )
+    )
+
+
 def _find_thinking_close(
     text: str,
     body_start: int,
@@ -252,6 +265,9 @@ def _find_thinking_close(
         if entml_after < 0 or invoke_abs < entml_after:
             return fault_close, len(_FAULT_THINKING_CLOSE)
     if entml_after >= 0:
+        after_entml = text[entml_after + len(_THINKING_CLOSE) :]
+        if tool_markup_follows_entml_thinking_close(after_entml):
+            return fault_close, len(_FAULT_THINKING_CLOSE)
         return entml_after, len(_THINKING_CLOSE)
     return -1, 0
 
@@ -353,26 +369,49 @@ def invoke_index_inside_unclosed_thinking(
     thinking_enabled: bool = True,
 ) -> bool:
     """``invoke_at`` 是否落在尚未闭合的 thinking 块内。"""
-    if invoke_at < 0:
-        return False
-    think_open, opened_plain = _find_earliest_thinking_open(
-        text, thinking_enabled=thinking_enabled
+    return invoke_index_inside_any_thinking_block(
+        text, invoke_at, thinking_enabled=thinking_enabled, unclosed_only=True,
     )
-    if think_open < 0 or invoke_at <= think_open:
+
+
+def invoke_index_inside_any_thinking_block(
+    text: str,
+    invoke_at: int,
+    *,
+    thinking_enabled: bool = True,
+    unclosed_only: bool = False,
+) -> bool:
+    """``invoke_at`` 是否落在 thinking 块内（``unclosed_only`` 时仅检查未闭合块）。"""
+    if invoke_at < 0:
         return False
-    gt = text.find(">", think_open)
-    if gt < 0:
-        return True
-    body_start = gt + 1
-    close_at, close_len = _find_thinking_close(
-        text,
-        body_start,
-        opened_plain=opened_plain,
-        thinking_enabled=thinking_enabled,
-    )
-    if close_at < 0:
-        return True
-    return invoke_at < close_at + close_len
+    i = 0
+    while i < len(text):
+        open_at, opened_plain = _find_earliest_thinking_open(
+            text, i, thinking_enabled=thinking_enabled,
+        )
+        if open_at < 0:
+            break
+        gt = text.find(">", open_at)
+        if gt < 0:
+            return invoke_at > open_at
+        body_start = gt + 1
+        close_at, close_len = _find_thinking_close(
+            text,
+            body_start,
+            opened_plain=opened_plain,
+            thinking_enabled=thinking_enabled,
+        )
+        if close_at < 0:
+            if open_at < invoke_at:
+                return True
+            break
+        block_end = close_at + close_len
+        if open_at < invoke_at < block_end:
+            return True
+        if unclosed_only:
+            return False
+        i = block_end
+    return False
 
 
 def split_entml_thinking(
@@ -415,6 +454,18 @@ def split_entml_thinking(
 
         parts.append(text[body_start:close_at])
         i = close_at + close_len
+        if (
+            close_len == len(_FAULT_THINKING_CLOSE)
+            and not opened_plain
+            and thinking_enabled
+        ):
+            entml_after = text.find(_THINKING_CLOSE, i)
+            if entml_after >= 0:
+                after_entml = text[entml_after + len(_THINKING_CLOSE) :]
+                if tool_markup_follows_entml_thinking_close(after_entml):
+                    clean_parts.append(text[i:entml_after])
+                    i = entml_after + len(_THINKING_CLOSE)
+                    continue
 
     clean = "".join(clean_parts)
     thinking = "\n".join(part.strip() for part in parts if part.strip())
@@ -426,16 +477,23 @@ def split_entml_thinking(
 
 
 def strip_orphan_thinking_close_prefix(text: str) -> str:
-    """去掉可见正文开头的 orphan ``</entml:thinking>``（流式分片边界）。"""
+    """去掉可见正文开头/末尾的 orphan ``</entml:thinking>``（流式分片边界）。"""
     if not text:
         return text
-    return re.sub(
+    text = re.sub(
         r"^\s*</entml:thinking>\s*",
         "",
         text,
         count=1,
         flags=re.IGNORECASE,
     )
+    return re.sub(
+        r"\s*</entml:thinking>\s*$",
+        "",
+        text,
+        count=1,
+        flags=re.IGNORECASE,
+    )
 
 
 def _hold_prefix(buffer: str, tag: str) -> Tuple[str, str]:
@@ -510,20 +568,27 @@ class EntmlThinkingStreamFilter:
         return True
 
     def _try_resolve_fault_watch_on_entml_close(self, out: List[Tuple[str, str]]) -> bool:
-        """未见 invoke 时出现 ``</entml:thinking>`` → ``</thinking>`` 仅为思考内纯文本。"""
+        """未见 invoke 时出现 ``</entml:thinking>`` → 若其后为 tool/invoke 则中间段为可见正文。"""
         if not self._fault_watch:
             return False
         close_at = self._fault_buffer.find(_THINKING_CLOSE)
         if close_at < 0:
             return False
-        emitted = self._emit_thinking_piece(self._fault_buffer[:close_at])
-        if emitted:
-            out.append(("thinking", emitted))
+        after_entml = self._fault_buffer[close_at + len(_THINKING_CLOSE) :]
+        if tool_markup_follows_entml_thinking_close(after_entml):
+            middle = self._fault_buffer[len(_FAULT_THINKING_CLOSE) : close_at]
+            visible = middle.strip()
+            if visible:
+                out.append(("content", visible))
+        else:
+            emitted = self._emit_thinking_piece(self._fault_buffer[:close_at])
+            if emitted:
+                out.append(("thinking", emitted))
         self._in_block = False
         self._opened_plain = False
         self._fault_watch = False
         self._thinking_started = False
-        self._pending = self._fault_buffer[close_at + len(_THINKING_CLOSE) :]
+        self._pending = after_entml
         self._fault_buffer = ""
         return True
 
@@ -574,15 +639,7 @@ class EntmlThinkingStreamFilter:
             self._pending = ""
             return False
 
-        safe, tool_hold = _hold_ambiguous_tool_markup(self._pending)
-        if tool_hold:
-            if safe:
-                emitted = self._emit_thinking_piece(safe)
-                if emitted:
-                    out.append(("thinking", emitted))
-            self._pending = tool_hold
-            return False
-
+        # thinking 块内 ``<entml:invoke>`` 等仅为 prose/示例时仍计入 thinking，不按工具 hold 截断。
         safe, hold = _hold_prefix(self._pending, _THINKING_CLOSE)
         if not hold and self._thinking_enabled:
             safe, hold = _hold_prefix(safe, _FAULT_THINKING_CLOSE)

{echotools-2.3.84 → echotools-2.3.86}/src/echotools/exec/fncall/protocols/entml_tool_blocks.py

@@ -24,9 +24,9 @@ _INNER_TOOL_TAG_RE = re.compile(
     re.IGNORECASE,
 )
 _BRACE_TOOL_HEAD_RE = re.compile(r"\{([A-Za-z][A-Za-z0-9_]*)\s*:\s*")
-# ``{Bash>`` 后接 ``<entml:parameter>`` 的混合格式（``{Edit: json}`` 仍走 history brace）
+# ``{Bash>`` / ``{Read}`` 后接 ``<entml:parameter>`` 的混合格式（``{Edit: json}`` 仍走 history brace）
 _MANGLED_BRACE_ENTML_HEAD_RE = re.compile(
-    r"^\s*\{([A-Za-z][A-Za-z0-9_]*)\s*>\s*",
+    r"^\s*\{([A-Za-z][A-Za-z0-9_]*)\s*(?:>|\})\s*",
     re.MULTILINE,
 )
 _PARAM_MARKER_RE = re.compile(

{echotools-2.3.84 → echotools-2.3.86}/src/echotools/exec/fncall/shared/history_markup.py

@@ -98,10 +98,11 @@ def _paired_block_glued_brace_re(tag: str) -> re.Pattern[str]:
     )
 
 
-def _orphan_close_re(tag: str) -> re.Pattern[str]:
+def _orphan_close_line_re(tag: str) -> re.Pattern[str]:
+    """无配对开标签的 ``</tag>`` 行：仅删该行，不删其前的合法可见正文。"""
     return re.compile(
-        rf"(?:^|\n)([\s\S]*?)\n\s*</{tag}\s*>\s*(?:\n|$)",
-        re.IGNORECASE,
+        rf"^\s*</{tag}\s*>\s*$",
+        re.IGNORECASE | re.MULTILINE,
     )
 
 
@@ -193,9 +194,9 @@ def _strip_fake_blocks_in_unprotected(
                     break
                 found = True
                 text = new_text
-        close_re = _orphan_close_re(tag)
+        close_re = _orphan_close_line_re(tag)
         while True:
-            new_text, n = close_re.subn("\n", text, count=1)
+            new_text, n = close_re.subn("", text, count=1)
             if n == 0:
                 break
             found = True

{echotools-2.3.84 → echotools-2.3.86}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.84 → echotools-2.3.86}/src/tests/fixtures/simulated_fake_history_markup_responses.py

@@ -110,7 +110,7 @@ def tools_for_markup_case(case: HistoryMarkupCase) -> List[Dict[str, Any]]:
 FAKE_HISTORY_MARKUP_CASES: Tuple[HistoryMarkupCase, ...] = (
     HistoryMarkupCase(
         id="model_edit_mimic_orphan_thinking",
-        description="Claude Code 高发：正文 + orphan </thinking> + 多块 Edit 伪 tool",
+        description="高发语料：正文 + orphan </thinking> + 多块 Edit 伪 tool",
         extra_tools=("Read", "Edit"),
         response=(
             "● 验证通过，无外部依赖残留。现在清理几个文件中遗留的旧路径注释。\n\n"
@@ -166,8 +166,8 @@ FAKE_HISTORY_MARKUP_CASES: Tuple[HistoryMarkupCase, ...] = (
         id="orphan_assistant_close",
         description="无开标签的 </assistant> 反向闭合",
         response="分析中...\n</assistant>\n后续仍可见",
-        expect_clean_contains=("后续仍可见",),
-        expect_clean_excludes=("分析中", "</assistant>"),
+        expect_clean_contains=("后续仍可见", "分析中"),
+        expect_clean_excludes=("</assistant>",),
     ),
     HistoryMarkupCase(
         id="fake_tool_bash_scalar",

{echotools-2.3.84 → echotools-2.3.86}/src/tests/fixtures/simulated_fault_thinking_responses.py

@@ -1,4 +1,4 @@
-"""模拟模型 ``<entml:thinking>…</thinking>`` fault 容错输出（rogator / Claude Code 高发）。
+"""模拟模型 ``<entml:thinking>…</thinking>`` fault 容错输出（rogator / agent 客户端高发）。
 
 非真实模型日志；用于 batch ``protocol.parse`` 与 ``FncallStreamParser`` 分流回归。
 """

{echotools-2.3.84 → echotools-2.3.86}/src/tests/fixtures/simulated_llm_tool_responses.py

@@ -99,7 +99,7 @@ TOOLS: List[Dict[str, Any]] = [
     },
 ]
 
-# Claude Code / rogator 链路常见工具（不在默认 TOOLS 内）
+# Anthropic 兼容客户端 / rogator 链路常见工具（不在默认 TOOLS 内）
 AGENT_TOOLS: List[Dict[str, Any]] = [
     {
         "type": "function",
@@ -580,7 +580,7 @@ SIMULATED_LLM_RESPONSES: List[SimulatedCase] = [
         expect_args=[{"city": "杭州", "unit": "c"}],
         expect_clean_substrings=["参考历史：", "我再确认一次实时天气。"],
     ),
-    # --- 模型分支：Claude Code / rogator 常见 agent 工具 ---
+    # --- 模型分支：Anthropic 兼容客户端 / rogator 常见 agent 工具 ---
     SimulatedCase(
         id="agent_write_windows_path",
         description="Write：Windows 绝对路径 + 含引号 contents",

{echotools-2.3.84 → echotools-2.3.86}/src/tests/test_entml_parser_comprehensive.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-"""entml 流式/批量解析器全方位测试：普通路径 + 边界 + rogator/Claude Code 高发场景。
+"""entml 流式/批量解析器全方位测试：普通路径 + 边界 + rogator/agent 客户端高发场景。
 
 与 test_simulated_llm_tool_parse / test_adversarial_stream_splits 互补：
 - 本文件聚焦 thinking/invoke 边界、fault ``</thinking>``、holdback 分片、

{echotools-2.3.84 → echotools-2.3.86}/src/tests/test_entml_protocol.py

@@ -518,16 +518,30 @@ def test_strip_entml_from_user_content() -> None:
 
     raw = (
         "请查天气\n"
-        "<entml:thinking>不应出现</entml:thinking>\n"
-        "<entml:function_calls><entml:invoke name=\"get_weather\">"
-        "<entml:parameter name=\"city\">杭州</entml:parameter>"
-        "</entml:invoke></entml:function_calls>"
+        "<entml:thinking>thinking body</entml:thinking>\n"
+        '<entml:invoke name="get_weather">'
+        '<entml:parameter name="city">杭州</entml:parameter>'
+        "</entml:invoke>"
     )
     cleaned = strip_entml_from_content(raw)
-    assert cleaned == "请查天气"
+    assert cleaned == (
+        "请查天气\n"
+        "<thinking>thinking body</thinking>\n"
+        '<invoke name="get_weather">'
+        '<parameter name="city">杭州</parameter>'
+        "</invoke>"
+    )
     assert "entml:" not in cleaned
-    assert "不应出现" not in cleaned
-    assert "杭州" not in cleaned
+    assert "thinking body" in cleaned
+    assert "杭州" in cleaned
+    assert cleaned.count("//") == raw.count("//")
+
+
+def test_strip_entml_from_user_preserves_double_slash() -> None:
+    from echotools.exec.fncall.protocols.entml import strip_entml_from_content
+
+    raw = '<entml:invoke name="x">//path//</entml:invoke>'
+    assert strip_entml_from_content(raw) == '<invoke name="x">//path//</invoke>'
 
 
 def test_inject_strips_entml_from_all_user_messages() -> None:
@@ -550,14 +564,12 @@ def test_inject_strips_entml_from_all_user_messages() -> None:
         },
     ]
     content = inject_fncall(msgs, [], proto)[0]["content"]
-    assert "secret" not in content
+    assert "secret" in content or "<thinking>secret</thinking>" in content
     assert "entml:invoke" not in content
-    assert "entml:thinking" not in content
-    assert "历史问题  继续" in content or "历史问题 继续" in content
-    assert "当前问题  结束" in content or "当前问题 结束" in content
-    assert "<current_user_message>\n当前问题  结束\n</current_user_message>" in content or (
-        "<current_user_message>\n当前问题 结束\n</current_user_message>" in content
-    )
+    assert '<invoke name="search">' in content or "search" in content
+    assert "历史问题" in content and "继续" in content
+    assert "当前问题" in content and "结束" in content
+    assert "<current_user_message>" in content
 
 
 def test_entml_multi_tool_history_blocks() -> None:
@@ -1025,7 +1037,7 @@ def test_inject_include_thinking_in_history() -> None:
 
 
 def test_entml_parse_bare_description_timeout_tags() -> None:
-    """Claude Code 风格：invoke 内裸 <entml:description>/<entml:timeout>。"""
+    """常见 agent 风格：invoke 内裸 <entml:description>/<entml:timeout>。"""
     tools = [
         {
             "type": "function",
@@ -1369,7 +1381,7 @@ def test_entml_stream_finalize_strips_thinking_when_tool_calls() -> None:
     assert len(calls) == 1
     assert calls[0]["function"]["name"] == "Bash"
     assert "<entml:thinking>" not in clean
-    assert "StreamAiPreviews" not in clean
+    assert "StreamAiPreviews" in parser.partial_thinking
     assert len(parser.partial_thinking) > 500
     assert "260727" in json.loads(calls[0]["function"]["arguments"])["command"]
 
@@ -1464,6 +1476,89 @@ def test_entml_tool_block_mangled_brace_entml_params() -> None:
         assert "RC4" in stream_clean or "RC4" in parser.partial_text, f"chunk={chunk}"
 
 
+def test_entml_tool_block_brace_read_entml_params() -> None:
+    """``<tool>{Read}\\n<entml:parameter>...`` + fault thinking（req-1785310901）。"""
+    from pathlib import Path
+
+    from echotools.exec.fncall.parsers.stream import FncallStreamParser
+
+    sample_path = Path(
+        r"X:/Project/Public/Qwen/logs/responses/req-1785310901-34c502c9e8a9.txt"
+    )
+    if not sample_path.is_file():
+        pytest.skip("corpus file not available")
+    sample = sample_path.read_text(encoding="utf-8")
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "Read",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {"type": "string"},
+                        "offset": {"type": "integer"},
+                        "limit": {"type": "integer"},
+                    },
+                    "required": ["file_path"],
+                },
+            },
+        }
+    ]
+    clean, batch_calls = get_protocol("entml").parse(sample, tools)
+    assert len(batch_calls) == 1
+    batch_args = json.loads(batch_calls[0]["function"]["arguments"])
+    assert batch_calls[0]["function"]["name"] == "Read"
+    assert batch_args["offset"] == 0
+    assert batch_args["limit"] == 200
+    assert "b01pggtpe.txt" in batch_args["file_path"]
+    assert "流发送逻辑" in clean
+    assert "entml:" not in clean
+
+    for chunk in (1, 17, 64):
+        parser = FncallStreamParser(protocol=get_protocol("entml"), tools=tools)
+        for i in range(0, len(sample), chunk):
+            parser.feed(sample[i : i + chunk])
+        stream_clean, stream_calls = parser.finalize()
+        assert len(stream_calls) == 1, f"chunk={chunk}"
+        stream_args = json.loads(stream_calls[0]["function"]["arguments"])
+        assert stream_args == batch_args, f"chunk={chunk}"
+        assert "流发送逻辑" in stream_clean, f"chunk={chunk}"
+        assert "流发送逻辑" not in parser.partial_thinking, f"chunk={chunk}"
+        assert len(parser.partial_thinking) > 500, f"chunk={chunk}"
+
+
+def test_entml_tool_block_mangled_brace_entml_params_brace_close() -> None:
+    """``{Read}``（非 ``{Read>``）后接 entml parameter 须解析。"""
+    from echotools.exec.fncall.protocols.entml_tool_blocks import parse_tool_block_body
+    from echotools.exec.fncall.shared.coercion import _build_param_schema_index
+
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "Read",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {"type": "string"},
+                        "offset": {"type": "integer"},
+                    },
+                    "required": ["file_path"],
+                },
+            },
+        }
+    ]
+    body = (
+        "{Read}\n"
+        '<entml:parameter name="file_path">src/a.py</entml:parameter>\n'
+        '<entml:parameter name="offset">10</entml:parameter>'
+    )
+    schema = _build_param_schema_index(tools)
+    parsed = parse_tool_block_body(body, tools=tools, schema_index=schema)
+    assert parsed == [("Read", {"file_path": "src/a.py", "offset": 10})]
+
+
 def test_prose_entml_invoke_mention_does_not_swallow_real_invoke() -> None:
     """正文提及 ``<entml:invoke>``（无 name）不得吞掉后续真实工具块（req-1785299710）。"""
     from pathlib import Path