echotools 2.3.39__tar.gz → 2.3.42__tar.gz

{echotools-2.3.39 → echotools-2.3.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.3.39
+Version: 2.3.42
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Author: nichengfuben
 License: MIT

{echotools-2.3.39 → echotools-2.3.42}/pyproject.toml

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

{echotools-2.3.39 → echotools-2.3.42}/src/echotools/exec/fncall/parsers/stream.py

@@ -13,7 +13,7 @@ from echotools.exec.protocol.base import ToolProtocol
 # 懒导入：仅 entml 协议需要
 def _make_thinking_filter(protocol: ToolProtocol):
     if getattr(protocol, "id", None) == "entml":
-        from echotools.exec.fncall.protocols.entml_thinking_parse import (
+        from echotools.exec.fncall.protocols.entml_think.parse import (
             EntmlThinkingStreamFilter,
         )
         return EntmlThinkingStreamFilter()
@@ -136,12 +136,59 @@ class FncallStreamParser:
 
         return buffer, ""
 
+    def _append_content_text(self, text: str) -> None:
+        if text:
+            self._text_parts.append(text)
+
+    def _feed_content_waiting(self, text: str) -> None:
+        """thinking 已闭合后，对可见正文做 invoke 检测（不再经过 thinking 过滤器）。"""
+        if not text:
+            return
+        trigger_tags = self._protocol.get_trigger_tags()
+        found, pos = self._protocol.detect_start(text)
+        if not found:
+            safe, remain = self._split_safe_text(text, trigger_tags)
+            if safe:
+                self._append_content_text(safe)
+            self._waiting_tail = remain
+            return
+
+        if pos > 0:
+            self._append_content_text(text[:pos])
+
+        self._fncall_buf = text[pos:]
+        self._detected = True
+        self._state = self.IN_FUNCTION_CALLS
+        if self._is_call_closed():
+            self._state = self.DONE
+
+    def _feed_waiting_thinking_plain(self, combined: str) -> None:
+        """未闭合 thinking 阶段：块内一律按纯文本进 thinking，不检测 invoke。"""
+        assert self._thinking_filter is not None
+        for kind, part in self._thinking_filter.feed(combined):
+            if kind == "thinking":
+                self._thinking_parts.append(part)
+            elif part:
+                self._feed_content_waiting(part)
+
     def _feed_waiting(self, chunk: str) -> None:
         """在 WAITING_FOR_TAG 状态下处理新块。"""
         combined = self._waiting_tail + chunk
-        found, pos = self._protocol.detect_start(combined)
+        self._waiting_tail = ""
+
+        if self._thinking_filter is not None:
+            from echotools.exec.fncall.protocols.entml_think.parse import (
+                has_unclosed_entml_thinking,
+            )
+            if (
+                self._thinking_filter.in_open_thinking()
+                or has_unclosed_entml_thinking(combined)
+            ):
+                self._feed_waiting_thinking_plain(combined)
+                return
 
         trigger_tags = self._protocol.get_trigger_tags()
+        found, pos = self._protocol.detect_start(combined)
 
         if not found:
             safe, remain = self._split_safe_text(combined, trigger_tags)
@@ -154,7 +201,6 @@ class FncallStreamParser:
             self._emit_text(combined[:pos])
 
         self._fncall_buf = combined[pos:]
-        self._waiting_tail = ""
         self._detected = True
         self._state = self.IN_FUNCTION_CALLS
 
@@ -216,7 +262,7 @@ class FncallStreamParser:
 
         # 兜底：剥离残留 <entml:thinking>（holdback 边界/分片异常时）
         if self._thinking_filter is not None and clean_text:
-            from echotools.exec.fncall.protocols.entml_thinking_parse import (
+            from echotools.exec.fncall.protocols.entml_think.parse import (
                 split_entml_thinking,
             )
             clean_text, more_thinking = split_entml_thinking(clean_text)

{echotools-2.3.39 → echotools-2.3.42}/src/echotools/exec/fncall/prompt/history.py

@@ -39,6 +39,45 @@ _TOOL_CALL_MARKER_RE = re.compile(
     re.MULTILINE,
 )
 
+# entml 标签清理正则
+_ENTML_FNCALL_BLOCK_RE = re.compile(
+    r"<entml:function_calls\b[^>]*>.*?</entml:function_calls>",
+    re.DOTALL,
+)
+_ENTML_INVOKE_RE = re.compile(
+    r'<entml:invoke\s+name="[^"]+"\s*>.*?</entml:invoke>',
+    re.DOTALL,
+)
+_ENTML_PARAMETERS_RE = re.compile(
+    r'<entml:parameters>.*?</entml:parameters>',
+    re.DOTALL,
+)
+_ENTML_PARAM_RE = re.compile(
+    r'<entml:parameter\s+name="[^"]+"[^>]*>.*?</entml:parameter>',
+    re.DOTALL,
+)
+# 清理任意 entml:* 标签
+_ENTML_ANY_TAG_RE = re.compile(
+    r'<entml:[a-zA-Z_][\w]*\b[^>]*>.*?</entml:[a-zA-Z_][\w]*>',
+    re.DOTALL,
+)
+
+
+def _clean_entml_tags(content: str) -> str:
+    """移除内容中的所有 entml 标签及其内部内容。"""
+    if not content:
+        return content
+    cleaned = content
+    cleaned = _ENTML_FNCALL_BLOCK_RE.sub("", cleaned)
+    cleaned = _ENTML_INVOKE_RE.sub("", cleaned)
+    cleaned = _ENTML_PARAMETERS_RE.sub("", cleaned)
+    cleaned = _ENTML_PARAM_RE.sub("", cleaned)
+    cleaned = _ENTML_ANY_TAG_RE.sub("", cleaned)
+    # 清理多余空行
+    lines = [line for line in cleaned.splitlines() if line.strip()]
+    return "\n".join(lines)
+
+
 # ---------------------------------------------------------------------------
 # 渲染工具调用 / 工具结果
 # ---------------------------------------------------------------------------

echotools-2.3.42/src/echotools/exec/fncall/prompt/history_format.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+"""Conversation history block formatting."""
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from echotools.exec.fncall.shared.normalization import normalize_content
+
+from .prompt_helpers import (
+    format_assistant_block,
+    format_assistant_block_with_results,
+    format_tool_block,
+    format_user_block,
+    join_history_parts,
+)
+
+
+def history_contains_tool_calls(messages: List[Dict[str, Any]]) -> bool:
+    """历史消息中是否包含 assistant tool_calls 或 tool 结果。"""
+    for m in messages:
+        role = m.get("role") or "user"
+        if role == "assistant" and m.get("tool_calls"):
+            return True
+        if role == "tool":
+            return True
+    return False
+
+
+def _append_user_part(
+    parts: List[Tuple[str, bool]],
+    m: Dict[str, Any],
+    clean_fn: Any,
+) -> None:
+    content_str = normalize_content(m.get("content", ""))
+    parts.append((format_user_block(content_str, clean_fn), False))
+
+
+def _append_assistant_part(
+    parts: List[Tuple[str, bool]],
+    messages: List[Dict[str, Any]],
+    index: int,
+    protocol: Optional[Any],
+    call_id_to_name: Dict[str, str],
+    seen_assistant_keys: set,
+    *,
+    include_thinking_in_history: bool,
+) -> int:
+    m = messages[index]
+    content_str = normalize_content(m.get("content", ""))
+    tcs = m.get("tool_calls") or []
+    if tcs:
+        tool_msgs = []
+        j = index + 1
+        while j < len(messages) and (messages[j].get("role") or "user") == "tool":
+            tool_msgs.append(messages[j])
+            j += 1
+        blocks = format_assistant_block_with_results(
+            m, tool_msgs, protocol, call_id_to_name, seen_assistant_keys,
+            include_thinking_in_history=include_thinking_in_history,
+        )
+        for block in blocks:
+            parts.append((block, False))
+        return j
+
+    blocks = format_assistant_block(
+        m, content_str, protocol, call_id_to_name, seen_assistant_keys,
+        include_thinking_in_history=include_thinking_in_history,
+    )
+    for block in blocks:
+        parts.append((block, False))
+    return index + 1
+
+
+def _format_conversation_history(
+    messages: List[Dict[str, Any]],
+    protocol: Optional[Any] = None,
+    *,
+    include_thinking_in_history: bool = False,
+) -> str:
+    if not messages:
+        return ""
+
+    call_id_to_name: Dict[str, str] = {}
+    seen_assistant_keys = set()
+    parts: List[Tuple[str, bool]] = []
+    clean_fn = protocol.clean_tags if protocol and hasattr(protocol, "clean_tags") else None
+
+    i = 0
+    while i < len(messages):
+        m = messages[i]
+        role: str = m.get("role") or "user"
+
+        if role == "user":
+            _append_user_part(parts, m, clean_fn)
+            i += 1
+            continue
+
+        if role == "assistant":
+            i = _append_assistant_part(
+                parts, messages, i, protocol, call_id_to_name,
+                seen_assistant_keys,
+                include_thinking_in_history=include_thinking_in_history,
+            )
+            continue
+
+        if role == "tool":
+            content_str = normalize_content(m.get("content", ""))
+            parts.append((format_tool_block(m, content_str, call_id_to_name), True))
+            i += 1
+            continue
+
+        content_str = normalize_content(m.get("content", ""))
+        parts.append((f"<{role}>\n{content_str}\n</{role}>", False))
+        i += 1
+
+    return join_history_parts(parts)

{echotools-2.3.39 → echotools-2.3.42}/src/echotools/exec/fncall/prompt/inject.py

@@ -22,8 +22,8 @@ from echotools.exec.fncall.protocols.entml import (
     format_entml_conversation_history,
     format_entml_current_user_message,
 )
-from echotools.exec.fncall.protocols.entml_thinking import build_entml_thinking_section
-from echotools.exec.fncall.protocols.entml_thinking_history import (
+from echotools.exec.fncall.protocols.entml_think.core import build_entml_thinking_section
+from echotools.exec.fncall.protocols.entml_think.hist import (
     apply_thinking_history_policy,
     parse_include_thinking_in_history,
 )
@@ -145,12 +145,13 @@ def inject_fncall(
     if not tools:
         if protocol.id == "entml":
             sections: List[str] = []
-            thinking_section = build_entml_thinking_section(protocol_options)
-            if thinking_section:
-                sections.append(thinking_section)
             if history_text.strip():
                 sections.append(format_entml_conversation_history(history_text))
             sections.append(format_entml_current_user_message(current_user_message))
+            # thinking 放在最后，超限截断时优先保留在 send_text 尾部
+            thinking_section = build_entml_thinking_section(protocol_options)
+            if thinking_section:
+                sections.append(thinking_section)
             prompt = "\n\n".join(sections)
         else:
             prompt = build_no_tools_prompt(history_text, current_user_message)

{echotools-2.3.39 → echotools-2.3.42}/src/echotools/exec/fncall/prompt/prompt_helpers.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Any, Dict, List, Optional, Set, Tuple
 
 from echotools.base.logger.manager import get_logger
-from echotools.exec.fncall.protocols.entml_thinking_history import (
+from echotools.exec.fncall.protocols.entml_think.hist import (
     extract_reasoning_text,
     format_entml_thinking_history_block,
 )

{echotools-2.3.39 → echotools-2.3.42}/src/echotools/exec/fncall/protocols/entml.py

@@ -8,6 +8,7 @@
 from __future__ import annotations
 
 import json as _json
+import re
 from typing import Any, Dict, List, Optional, Tuple
 
 from echotools.exec.fncall.prompt.templates import (
@@ -18,8 +19,7 @@ from echotools.exec.fncall.protocols.entml_invoke import (
     parse_entml_tool_calls,
 )
 from echotools.exec.fncall.protocols.entml_patterns import BLOCK_RE
-from echotools.exec.fncall.protocols.entml_sanitize import strip_entml_from_content
-from echotools.exec.fncall.protocols.entml_thinking import build_entml_thinking_section
+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.coercion import _build_param_schema_index
 from echotools.exec.fncall.shared.normalization import (
@@ -28,6 +28,27 @@ 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)
+
+
+def strip_entml_from_content(content: str) -> str:
+    """从 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()
+
 
 def _parse_tool_call_args(tc: Dict[str, Any]) -> tuple[str, Dict[str, Any]]:
     fn = tc.get("function") or {}
@@ -141,10 +162,6 @@ class EntmlProtocol(ToolProtocol):
         else:
             sections = [_ENTML_INSTRUCTION.rstrip()]
 
-        thinking_section = build_entml_thinking_section(protocol_options)
-        if thinking_section:
-            sections.append(thinking_section)
-
         if user_system_prompt and user_system_prompt.strip():
             sections.append(
                 f"<user_system_prompt>\n{user_system_prompt.strip()}\n</user_system_prompt>"
@@ -161,6 +178,12 @@ class EntmlProtocol(ToolProtocol):
             sections.append(f"<loop_warning>\n{loop_warning}\n</loop_warning>")
 
         sections.append(format_entml_current_user_message(current_user_message))
+
+        # thinking 放在最后，超限截断时优先保留在 send_text 尾部
+        thinking_section = build_entml_thinking_section(protocol_options)
+        if thinking_section:
+            sections.append(thinking_section)
+
         return "\n\n".join(sections)
 
     def detect_start(self, buffer: str) -> Tuple[bool, int]:

echotools-2.3.42/src/echotools/exec/fncall/protocols/entml_think/__init__.py

@@ -0,0 +1,31 @@
+"""Entml thinking: prompt section, history blocks, stream parsing."""
+
+from echotools.exec.fncall.protocols.entml_think.core import (
+    build_entml_thinking_section,
+    parse_max_thinking_length,
+)
+from echotools.exec.fncall.protocols.entml_think.hist import (
+    apply_thinking_history_policy,
+    extract_reasoning_text,
+    format_entml_thinking_history_block,
+    parse_include_thinking_in_history,
+    parse_interleaved_history,
+)
+from echotools.exec.fncall.protocols.entml_think.parse import (
+    EntmlThinkingStreamFilter,
+    has_unclosed_entml_thinking,
+    split_entml_thinking,
+)
+
+__all__ = [
+    "EntmlThinkingStreamFilter",
+    "apply_thinking_history_policy",
+    "build_entml_thinking_section",
+    "extract_reasoning_text",
+    "format_entml_thinking_history_block",
+    "has_unclosed_entml_thinking",
+    "parse_include_thinking_in_history",
+    "parse_interleaved_history",
+    "parse_max_thinking_length",
+    "split_entml_thinking",
+]

echotools-2.3.39/src/echotools/exec/fncall/protocols/entml_thinking_parse.py → echotools-2.3.42/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -12,6 +12,31 @@ _THINKING_OPEN_PREFIX = "<entml:thinking"
 _THINKING_CLOSE = "</entml:thinking>"
 
 
+def has_unclosed_entml_thinking(text: str) -> bool:
+    """buffer 中是否存在尚未闭合的 <entml:thinking> 块（含开标签未收齐）。"""
+    if not text:
+        return False
+    i = 0
+    while i < len(text):
+        open_at = text.find(_THINKING_OPEN_PREFIX, i)
+        if open_at < 0:
+            break
+        gt = text.find(">", open_at)
+        if gt < 0:
+            return True
+        close_at = text.find(_THINKING_CLOSE, gt + 1)
+        if close_at < 0:
+            return True
+        i = close_at + len(_THINKING_CLOSE)
+    max_keep = len(_THINKING_OPEN_PREFIX) - 1
+    check_len = min(len(text), max_keep)
+    for length in range(check_len, 0, -1):
+        suffix = text[-length:]
+        if _THINKING_OPEN_PREFIX.startswith(suffix) and suffix != _THINKING_OPEN_PREFIX:
+            return True
+    return False
+
+
 def split_entml_thinking(text: str) -> Tuple[str, str]:
     """从文本中剥离 <entml:thinking> 块，返回 (正文, 思考链拼接)。"""
     if not text:
@@ -53,6 +78,63 @@ class EntmlThinkingStreamFilter:
         # 当前 thinking 块是否已输出过任何内容（用于首片去前导空白）
         self._thinking_started = False
 
+    def in_open_thinking(self) -> bool:
+        """思考块已开始且尚未收到 </entml:thinking>（含开/闭标签分片 hold）。"""
+        if self._in_block:
+            return True
+        open_at = self._pending.find(_THINKING_OPEN_PREFIX)
+        if open_at >= 0:
+            gt = self._pending.find(">", open_at)
+            if gt < 0:
+                return True
+        _, hold = _hold_prefix(self._pending, _THINKING_OPEN_PREFIX)
+        if hold:
+            return True
+        return False
+
+    def _feed_in_block(self, out: List[Tuple[str, str]]) -> bool:
+        """处理块内 pending；返回 False 表示应退出 feed 主循环。"""
+        close_at = self._pending.find(_THINKING_CLOSE)
+        if close_at >= 0:
+            piece = self._pending[:close_at]
+            emitted = self._emit_thinking_piece(piece)
+            if emitted:
+                out.append(("thinking", emitted))
+            self._in_block = False
+            self._thinking_started = False
+            self._pending = self._pending[close_at + len(_THINKING_CLOSE) :]
+            return True
+
+        safe, hold = _hold_prefix(self._pending, _THINKING_CLOSE)
+        if safe:
+            emitted = self._emit_thinking_piece(safe)
+            if emitted:
+                out.append(("thinking", emitted))
+        self._pending = hold
+        return False
+
+    def _feed_before_block(self, out: List[Tuple[str, str]]) -> bool:
+        """开标签之前或尚未进入块；返回 False 表示应退出 feed 主循环。"""
+        open_at = self._pending.find(_THINKING_OPEN_PREFIX)
+        if open_at < 0:
+            safe, self._pending = _hold_prefix(self._pending, _THINKING_OPEN_PREFIX)
+            if safe:
+                out.append(("content", safe))
+            return False
+
+        if open_at > 0:
+            out.append(("content", self._pending[:open_at]))
+            self._pending = self._pending[open_at:]
+
+        gt = self._pending.find(">")
+        if gt < 0:
+            return False
+
+        self._in_block = True
+        self._thinking_started = False
+        self._pending = self._pending[gt + 1 :]
+        return True
+
     def feed(self, chunk: str) -> List[Tuple[str, str]]:
         """返回 [(kind, text), ...]，kind 为 content 或 thinking。"""
         if not chunk:
@@ -63,46 +145,12 @@ class EntmlThinkingStreamFilter:
 
         while self._pending:
             if self._in_block:
-                close_at = self._pending.find(_THINKING_CLOSE)
-                if close_at >= 0:
-                    piece = self._pending[:close_at]
-                    emitted = self._emit_thinking_piece(piece)
-                    if emitted:
-                        out.append(("thinking", emitted))
-                    self._in_block = False
-                    self._thinking_started = False
-                    self._pending = self._pending[close_at + len(_THINKING_CLOSE) :]
-                    continue
-
-                # 关闭标签可能被分片：hold 真前缀，其余立即作为 thinking 输出
-                safe, hold = _hold_prefix(self._pending, _THINKING_CLOSE)
-                if safe:
-                    emitted = self._emit_thinking_piece(safe)
-                    if emitted:
-                        out.append(("thinking", emitted))
-                self._pending = hold
+                if not self._feed_in_block(out):
+                    break
+                continue
+            if not self._feed_before_block(out):
                 break
 
-            open_at = self._pending.find(_THINKING_OPEN_PREFIX)
-            if open_at < 0:
-                safe, self._pending = _hold_prefix(self._pending, _THINKING_OPEN_PREFIX)
-                if safe:
-                    out.append(("content", safe))
-                break
-
-            if open_at > 0:
-                out.append(("content", self._pending[:open_at]))
-                self._pending = self._pending[open_at:]
-
-            gt = self._pending.find(">")
-            if gt < 0:
-                # 开标签属性未收齐
-                break
-
-            self._in_block = True
-            self._thinking_started = False
-            self._pending = self._pending[gt + 1 :]
-
         return out
 
     def _emit_thinking_piece(self, piece: str) -> str:

{echotools-2.3.39 → echotools-2.3.42}/src/echotools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.3.39
+Version: 2.3.42
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Author: nichengfuben
 License: MIT

{echotools-2.3.39 → echotools-2.3.42}/src/echotools.egg-info/SOURCES.txt

@@ -57,12 +57,12 @@ src/echotools/exec/fncall/protocols/__init__.py
 src/echotools/exec/fncall/protocols/entml.py
 src/echotools/exec/fncall/protocols/entml_invoke.py
 src/echotools/exec/fncall/protocols/entml_patterns.py
-src/echotools/exec/fncall/protocols/entml_sanitize.py
-src/echotools/exec/fncall/protocols/entml_thinking.py
-src/echotools/exec/fncall/protocols/entml_thinking_history.py
-src/echotools/exec/fncall/protocols/entml_thinking_parse.py
 src/echotools/exec/fncall/protocols/entml_tools.py
 src/echotools/exec/fncall/protocols/entml_values.py
+src/echotools/exec/fncall/protocols/entml_think/__init__.py
+src/echotools/exec/fncall/protocols/entml_think/core.py
+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/loop_detect.py
@@ -167,6 +167,7 @@ src/tests/test_events.py
 src/tests/test_events_event.py
 src/tests/test_facade.py
 src/tests/test_fncall.py
+src/tests/test_fncall_stream_thinking.py
 src/tests/test_ids.py
 src/tests/test_imports.py
 src/tests/test_io.py

{echotools-2.3.39 → echotools-2.3.42}/src/tests/test_entml_protocol.py

@@ -6,7 +6,7 @@ import pytest
 
 from echotools.exec.fncall import get_protocol, inject_fncall
 from echotools.exec.fncall.protocols.entml_invoke import parse_entml_tool_calls
-from echotools.exec.fncall.protocols.entml_thinking import (
+from echotools.exec.fncall.protocols.entml_think.core import (
     build_entml_thinking_section,
     default_max_thinking_length_for_level,
     normalize_thinking_level,
@@ -77,7 +77,7 @@ def test_build_entml_thinking_section_empty_without_options() -> None:
 
 
 def test_parse_max_thinking_length() -> None:
-    from echotools.exec.fncall.protocols.entml_thinking import parse_max_thinking_length
+    from echotools.exec.fncall.protocols.entml_think.core import parse_max_thinking_length
 
     assert parse_max_thinking_length(None) is None
     assert parse_max_thinking_length("") is None
@@ -223,6 +223,33 @@ def test_inject_no_tools_with_thinking_on() -> None:
     assert "<entml:thinking_mode>on</entml:thinking_mode>" in result
     assert "<thinking_behavior>" in result
     assert "Never skip the thinking block" in result
+    # thinking 块必须在 current_user_message 之后
+    assert result.index("</current_user_message>") < result.index("<entml:thinking_mode>")
+
+
+def test_render_prompt_thinking_after_current_user() -> None:
+    proto = get_protocol("entml")
+    prompt = proto.render_prompt(
+        tool_descs=proto.format_tool_descs([
+            {
+                "type": "function",
+                "function": {
+                    "name": "search",
+                    "description": "Search",
+                    "parameters": {"type": "object", "properties": {}},
+                },
+            }
+        ]),
+        lang="en",
+        history_text="<user>\nold\n</user>",
+        current_user_message="new",
+        protocol_options={"thinking_mode": "on", "max_thinking_length": 1000},
+    )
+    assert prompt.index("In this environment") < prompt.index("<entml:conversation_history>")
+    assert prompt.index("<entml:conversation_history>") < prompt.index("<current_user_message>")
+    assert prompt.index("</current_user_message>") < prompt.index("<entml:thinking_mode>")
+    assert prompt.index("<entml:thinking_mode>") < prompt.index("<thinking_behavior>")
+    assert prompt.rstrip().endswith("</thinking_behavior>")
 
 
 def test_inject_with_history_entml_tags() -> None:
@@ -316,7 +343,7 @@ def test_entml_history_tool_invoke_reminder_when_tools_in_history() -> None:
 
 
 def test_strip_entml_from_user_content() -> None:
-    from echotools.exec.fncall.protocols.entml_sanitize import strip_entml_from_content
+    from echotools.exec.fncall.protocols.entml import strip_entml_from_content
 
     raw = (
         "请查天气\n"

{echotools-2.3.39 → echotools-2.3.42}/src/tests/test_entml_thinking_history.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from echotools.exec.fncall.protocols.entml_thinking_history import (
+from echotools.exec.fncall.protocols.entml_think.hist import (
     apply_thinking_history_policy,
     extract_reasoning_text,
     parse_interleaved_history,

{echotools-2.3.39 → echotools-2.3.42}/src/tests/test_entml_thinking_parse.py

@@ -1,5 +1,6 @@
-from echotools.exec.fncall.protocols.entml_thinking_parse import (
+from echotools.exec.fncall.protocols.entml_think.parse import (
     EntmlThinkingStreamFilter,
+    has_unclosed_entml_thinking,
     split_entml_thinking,
 )
 
@@ -16,6 +17,11 @@ def test_split_entml_thinking() -> None:
     assert "<entml:thinking>" not in content
 
 
+def test_has_unclosed_entml_thinking_streaming_prefix() -> None:
+    assert has_unclosed_entml_thinking("<entml:think")
+    assert not has_unclosed_entml_thinking("<entml:thinking>done</entml:thinking>")
+
+
 def test_entml_thinking_stream_filter() -> None:
     filt = EntmlThinkingStreamFilter()
     parts = []