echotools 2.3.83__tar.gz → 2.3.85__tar.gz

{echotools-2.3.83 → echotools-2.3.85}/PKG-INFO

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

{echotools-2.3.83 → echotools-2.3.85}/pyproject.toml

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

{echotools-2.3.83 → echotools-2.3.85}/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

{echotools-2.3.83 → echotools-2.3.85}/src/echotools/exec/fncall/protocols/entml.py

@@ -23,10 +23,10 @@ from echotools.exec.fncall.protocols.entml_tool_blocks import (
     strip_tool_block_spans,
 )
 from echotools.exec.fncall.protocols.entml_patterns import (
-    BLOCK_RE,
     entml_invoke_open_may_be_streaming,
     extract_attr_value,
     normalize_entml_name,
+    strip_actionable_entml_invoke_blocks,
     strip_legacy_function_calls_wrapper,
     strip_tool_entml_residue,
 )
@@ -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]]:
@@ -308,7 +297,7 @@ class EntmlProtocol(ToolProtocol):
         # 须在移除 invoke 之前剥离伪 history，且须晚于已解析的 ``<tool>`` 块剥离。
         clean, _ = strip_fake_history_markup(clean)
         if tool_calls:
-            clean = BLOCK_RE.sub("", clean)
+            clean = strip_actionable_entml_invoke_blocks(clean)
         clean = strip_tool_entml_residue(clean)
         return (clean, normalize_tool_calls(tool_calls, tools))
 
@@ -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.83 → echotools-2.3.85}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -5,20 +5,19 @@ from typing import Any, Dict, List, Optional
 
 from .entml_patterns import (
     BARE_INVOKE_CHILD_RE,
-    INVOKE_DIRECT_CHILD_OPEN_RE,
     INVOKE_DIRECT_CHILD_RE,
     INVOKE_DIRECT_CHILD_SKIP,
-    INVOKE_RE,
     PARAM_RE,
     PARAMETERS_RE,
     extract_attr_value,
     extract_parameter_type_attr,
+    iter_actionable_entml_invoke_blocks,
     normalize_entml_name,
     parse_sub_tags,
     split_mangled_json_param_tail,
     synthetic_close_invoke_body,
 )
-from .entml_values import coerce_entml_arguments, coerce_entml_parameter_value
+from .entml_values import coerce_entml_arguments, coerce_entml_parameter_value, _coerce_entml_arg_value
 
 
 def _parse_direct_child_tags(
@@ -98,13 +97,10 @@ def parse_invoke_args(
             if extra_key in args:
                 continue
             extra_schema = func_props.get(extra_key) or {}
-            if isinstance(extra_val, (int, float, bool)):
-                args[extra_key] = extra_val
-            else:
-                args[extra_key] = coerce_entml_parameter_value(
-                    str(extra_val),
-                    extra_schema or None,
-                )
+            args[extra_key] = _coerce_entml_arg_value(
+                extra_val,
+                extra_schema or None,
+            )
 
     _parse_bare_invoke_children(body, args, func_props)
     _parse_direct_child_tags(body, args, func_props)
@@ -118,13 +114,12 @@ def parse_entml_tool_calls(
     schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]],
 ) -> List[Dict[str, Any]]:
     tool_calls: List[Dict[str, Any]] = []
-    for invoke_m in INVOKE_RE.finditer(text):
-        attrs = invoke_m.group(1) or ""
+    for _start, _end, attrs, body in iter_actionable_entml_invoke_blocks(text):
         name = extract_attr_value(attrs, "name")
         if not name:
             continue
         name = normalize_entml_name(name)
-        args = parse_invoke_args(invoke_m.group(2), name, schema_index)
+        args = parse_invoke_args(body, name, schema_index)
         arguments = json.dumps(args, ensure_ascii=False)
         tool_calls.append(
             {

{echotools-2.3.83 → echotools-2.3.85}/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+import json
 import re
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Tuple
 
 from .entml_values import coerce_entml_parameter_value
 
@@ -50,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,
@@ -101,6 +102,7 @@ _FENCE_ONLY_LINE_RE = re.compile(
     re.IGNORECASE | re.MULTILINE,
 )
 _INVOKE_OPEN_PREFIX = "<entml:invoke"
+_INVOKE_CLOSE = "</entml:invoke>"
 _PLACEHOLDER_INVOKE_NAMES = frozenset({"$FUNCTION_NAME", "$FUNCTION_NAME2"})
 
 
@@ -137,6 +139,76 @@ def entml_invoke_open_may_be_streaming(buffer: str, pos: int) -> bool:
     return False
 
 
+def _actionable_invoke_open_before_close(content: str, close_pos: int) -> bool:
+    """``close_pos`` 处的 ``</entml:invoke>`` 是否闭合带真实 name 的开标签。"""
+    search = close_pos - 1
+    while search >= 0:
+        pos = content.rfind(_INVOKE_OPEN_PREFIX, 0, search + 1)
+        if pos < 0:
+            return False
+        if entml_invoke_open_is_actionable(content, pos):
+            gt = content.find(">", pos)
+            if gt < 0 or gt >= close_pos:
+                search = pos - 1
+                continue
+            inner_close = content.find(_INVOKE_CLOSE, gt + 1, close_pos)
+            if inner_close < 0:
+                return True
+            search = pos - 1
+            continue
+        search = pos - 1
+    return False
+
+
+def _invoke_close_should_strip(content: str, close_pos: int) -> bool:
+    """是否应剥离 ``</entml:invoke>``（孤儿噪声或真实工具块残留）。"""
+    if _actionable_invoke_open_before_close(content, close_pos):
+        return True
+    open_pos = content.rfind(_INVOKE_OPEN_PREFIX, 0, close_pos)
+    if open_pos < 0:
+        return True
+    return entml_invoke_open_is_actionable(content, open_pos)
+
+
+def iter_actionable_entml_invoke_blocks(text: str) -> Iterator[Tuple[int, int, str, str]]:
+    """迭代含真实 ``name`` 的完整 ``<entml:invoke>…</entml:invoke>`` 块。"""
+    if not text:
+        return
+    search_from = 0
+    prefix_len = len(_INVOKE_OPEN_PREFIX)
+    close_len = len(_INVOKE_CLOSE)
+    while search_from < len(text):
+        pos = text.find(_INVOKE_OPEN_PREFIX, search_from)
+        if pos < 0:
+            break
+        if not entml_invoke_open_is_actionable(text, pos):
+            search_from = pos + prefix_len
+            continue
+        gt = text.find(">", pos + prefix_len)
+        if gt < 0:
+            break
+        close = text.find(_INVOKE_CLOSE, gt + 1)
+        if close < 0:
+            break
+        attrs = text[pos + prefix_len : gt]
+        body = text[gt + 1 : close]
+        yield pos, close + close_len, attrs, body
+        search_from = close + close_len
+
+
+def strip_actionable_entml_invoke_blocks(text: str) -> str:
+    """仅剥离含真实 ``name`` 的 invoke 块；保留 prose ``<entml:invoke>`` 提及。"""
+    if not text:
+        return text
+    parts: List[str] = []
+    last = 0
+    for start, end, _attrs, _body in iter_actionable_entml_invoke_blocks(text):
+        parts.append(text[last:start])
+        last = end
+    parts.append(text[last:])
+    return "".join(parts)
+
+
 def _strip_orphan_invoke_tags(content: str) -> str:
     """仅剥离带真实 name 的 invoke 孤儿标签；保留 prose 中的 ``<entml:invoke>`` 提及。"""
     pattern = re.compile(r"</?entml:invoke\b[^>]*/?>", re.DOTALL)
@@ -144,7 +216,9 @@ def _strip_orphan_invoke_tags(content: str) -> str:
     def repl(match: re.Match[str]) -> str:
         tag = match.group(0)
         if tag.startswith("</"):
-            return ""
+            if _invoke_close_should_strip(content, match.start()):
+                return ""
+            return tag
         if entml_invoke_open_is_actionable(content, match.start()):
             return ""
         return tag
@@ -224,15 +298,29 @@ _MANGLED_PARAM_JSON_COMMA_AFTER_QUOTE_RE = re.compile(
 )
 
 
+def _param_value_is_json_container(value: str) -> bool:
+    stripped = (value or "").lstrip()
+    return bool(stripped) and stripped[0] in "{["
+
+
 def mangled_json_param_tail_in_progress(value: str) -> bool:
     """parameter 值中出现误写入 JSON 尾缀但尚未收齐时不应继续增长 partial_json。"""
-    return bool(value and _MANGLED_PARAM_JSON_TAIL_IN_PROGRESS_RE.search(value))
+    if not value or _param_value_is_json_container(value):
+        return False
+    return bool(_MANGLED_PARAM_JSON_TAIL_IN_PROGRESS_RE.search(value))
 
 
 def split_mangled_json_param_tail(value: str) -> Tuple[str, Dict[str, Any]]:
     """模型把 ``", "description": ..., "timeout": ...}}`` 误写入 parameter 值时的拆分。"""
     if not value:
         return value, {}
+    if _param_value_is_json_container(value):
+        try:
+            json.loads(value)
+            return value, {}
+        except json.JSONDecodeError:
+            # 合法 JSON 数组/对象（含 options.description 等）不得走标量 command 尾缀启发式。
+            return value, {}
     match = _MANGLED_PARAM_JSON_TAIL_RE.search(value)
     if match:
         command = value[: match.start() + 1]
@@ -365,7 +453,7 @@ def strip_tool_entml_residue(content: str) -> str:
     if not content:
         return content
     cleaned = _TOOL_WRAPPER_PAIR_RE.sub("", content)
-    cleaned = BLOCK_RE.sub("", cleaned)
+    cleaned = strip_actionable_entml_invoke_blocks(cleaned)
     cleaned = _strip_orphan_invoke_tags(cleaned)
     cleaned = _strip_orphan_non_invoke_tool_tags(cleaned)
     cleaned = _EMPTY_FENCE_RE.sub("", cleaned)

{echotools-2.3.83 → echotools-2.3.85}/src/echotools/exec/fncall/protocols/entml_stream_json.py

@@ -21,8 +21,7 @@ from .entml_patterns import (
     split_mangled_json_param_tail,
     synthetic_close_invoke_body,
 )
-from .entml_values import coerce_entml_parameter_value
-from echotools.exec.fncall.shared.coercion import _resolve_effective_type
+from .entml_values import coerce_entml_parameter_value, effective_entml_param_json_type
 
 _PARAM_OPEN_RE = re.compile(rf"{PARAM_OPEN_PATTERN}([^>]*)>", re.IGNORECASE)
 _PARAM_CLOSE = PARAM_CLOSE_ENTML
@@ -31,22 +30,6 @@ _PARAMETERS_CLOSE = "</entml:parameters>"
 _INVOKE_CLOSE = "</entml:invoke>"
 _INVOKE_OPEN_PREFIX = "<entml:invoke"
 
-_TYPE_HINT_TO_JSON_TYPE = {
-    "str": "string",
-    "string": "string",
-    "int": "integer",
-    "integer": "integer",
-    "float": "number",
-    "number": "number",
-    "double": "number",
-    "bool": "boolean",
-    "boolean": "boolean",
-    "array": "array",
-    "list": "array",
-    "object": "object",
-    "dict": "object",
-}
-
 
 def _strip_incomplete_markup_suffix(value: str) -> str:
     lt = value.rfind("<")
@@ -89,20 +72,7 @@ def _effective_param_type(
     pschema: Optional[Dict[str, Any]],
     type_hint: Optional[str],
 ) -> str:
-    if type_hint:
-        mapped = _TYPE_HINT_TO_JSON_TYPE.get(type_hint.strip().lower())
-        if mapped:
-            return mapped
-    if pschema:
-        resolved = _resolve_effective_type(pschema)
-        if resolved:
-            return resolved
-    stripped = (value or "").lstrip()
-    if stripped.startswith("["):
-        return "array"
-    if stripped.startswith("{"):
-        return "object"
-    return "string"
+    return effective_entml_param_json_type(value, pschema, type_hint)
 
 
 def _synthetic_close_body(inner: str) -> str:

{echotools-2.3.83 → echotools-2.3.85}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -353,26 +353,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(
@@ -574,15 +597,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.83 → echotools-2.3.85}/src/echotools/exec/fncall/protocols/entml_values.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from typing import Any, Dict, Optional
 
-from echotools.exec.fncall.shared.coercion import _coerce_param_value
+from echotools.exec.fncall.shared.coercion import _coerce_param_value, _resolve_effective_type
 
 _TYPE_HINT_TO_JSON_TYPE = {
     "str": "string",
@@ -71,6 +71,44 @@ def coerce_entml_parameter_value(
     return stripped
 
 
+def effective_entml_param_json_type(
+    value: str,
+    schema: Optional[Dict[str, Any]] = None,
+    type_hint: Optional[str] = None,
+) -> str:
+    """流式 partial_json 与 batch 共用：模型 type 优先，否则 schema，再否则按值推断。"""
+    effective = resolve_entml_parameter_schema(schema, type_hint)
+    if effective:
+        resolved = _resolve_effective_type(effective)
+        if resolved:
+            return resolved
+    stripped = (value or "").lstrip()
+    if stripped.startswith("["):
+        return "array"
+    if stripped.startswith("{"):
+        return "object"
+    return "string"
+
+
+def _coerce_entml_arg_value(
+    value: Any,
+    schema: Optional[Dict[str, Any]] = None,
+    type_hint: Optional[str] = None,
+) -> Any:
+    """将已解析的 Python 值再按 type_hint / schema 归一（与 batch 单参路径一致）。"""
+    if isinstance(value, str):
+        return coerce_entml_parameter_value(value, schema, type_hint=type_hint)
+    if isinstance(value, (dict, list)):
+        return coerce_entml_parameter_value(
+            json.dumps(value, ensure_ascii=False),
+            schema,
+            type_hint=type_hint,
+        )
+    if value is None:
+        return coerce_entml_parameter_value("", schema, type_hint=type_hint)
+    return coerce_entml_parameter_value(str(value), schema, type_hint=type_hint)
+
+
 def coerce_entml_arguments(
     args: Dict[str, Any],
     func_name: str,
@@ -86,8 +124,8 @@ def coerce_entml_arguments(
     out: Dict[str, Any] = {}
     for key, value in args.items():
         pschema = func_schema.get(key) or {}
-        if isinstance(value, str) and pschema:
-            out[key] = coerce_entml_parameter_value(value, pschema)
+        if pschema:
+            out[key] = _coerce_entml_arg_value(value, pschema)
         else:
             out[key] = value
     return out

{echotools-2.3.83 → echotools-2.3.85}/src/echotools/exec/fncall/shared/coercion.py

@@ -199,6 +199,9 @@ def _coerce_to_array(raw: str, parsed: Any, item_schema: Dict[str, Any]) -> Any:
     if result_list is None:
         result_list = _try_parse_json_list(raw)
 
+    if result_list is None and isinstance(parsed, dict):
+        result_list = [parsed]
+
     if result_list is None:
         logger.debug("_coerce_to_array: 无法解析为列表，原样返回 %r", raw[:100])
         return parsed

{echotools-2.3.83 → echotools-2.3.85}/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.83 → echotools-2.3.85}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.83 → echotools-2.3.85}/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.83 → echotools-2.3.85}/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.83 → echotools-2.3.85}/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.83 → echotools-2.3.85}/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 分片、