echotools 2.3.40__tar.gz → 2.3.43__tar.gz

{echotools-2.3.40 → echotools-2.3.43}/PKG-INFO

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

{echotools-2.3.40 → echotools-2.3.43}/pyproject.toml

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

{echotools-2.3.40 → echotools-2.3.43}/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()
@@ -177,7 +177,7 @@ class FncallStreamParser:
         self._waiting_tail = ""
 
         if self._thinking_filter is not None:
-            from echotools.exec.fncall.protocols.entml_thinking_parse import (
+            from echotools.exec.fncall.protocols.entml_think.parse import (
                 has_unclosed_entml_thinking,
             )
             if (
@@ -262,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.40 → echotools-2.3.43}/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.43/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.40 → echotools-2.3.43}/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.40 → echotools-2.3.43}/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.40 → echotools-2.3.43}/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.43/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.40/src/echotools/exec/fncall/protocols/entml_thinking.py → echotools-2.3.43/src/echotools/exec/fncall/protocols/entml_think/core.py

@@ -53,11 +53,11 @@ _INJECTION_MODE_ALIASES: Dict[str, str] = {
 }
 
 _DEFAULT_MAX_BY_LEVEL: Dict[str, int] = {
-    "low": 6554,
-    "medium": 13108,
-    "high": 32768,
-    "xhigh": 52428,
-    "max": 62260,
+    "low": 12800,
+    "medium": 25600,
+    "high": 64000,
+    "xhigh": 102400,
+    "max": 134736,
 }
 
 _LEGACY_ON_DEFAULT_MAX = _DEFAULT_MAX_BY_LEVEL["medium"]
@@ -120,9 +120,12 @@ def parse_max_thinking_length(value: Any) -> Optional[int]:
 def resolve_thinking_injection(
     protocol_options: Optional[Dict[str, Any]] = None,
 ) -> Optional[Tuple[str, Optional[int]]]:
-    """解析注入用 thinking_mode (on/auto) 与 max_thinking_length。
+    """解析注入用 thinking_mode 与 max_thinking_length。
 
-    返回 None 表示不注入任何思考相关内容（none / off）。
+    - thinking_level 为 low|medium|high|xhigh|max 时，thinking_mode 直接传该挡位名。
+    - 仅 thinking_mode=on（无 level）时用 ``on``，并按 medium 默认长度。
+    - auto 传 ``auto``，无默认 max_thinking_length。
+    - none / off 返回 None，不注入任何思考相关内容。
     """
     opts = protocol_options or {}
 
@@ -130,8 +133,12 @@ def resolve_thinking_injection(
     if level is not None:
         if level == "none":
             return None
-        injection_mode = "auto" if level == "auto" else "on"
-        default_max = default_max_thinking_length_for_level(level)
+        if level == "auto":
+            injection_mode = "auto"
+            default_max = None
+        else:
+            injection_mode = level
+            default_max = default_max_thinking_length_for_level(level)
     else:
         mode = normalize_thinking_mode(opts.get("thinking_mode"))
         if mode is None or mode == "off":
@@ -144,8 +151,12 @@ def resolve_thinking_injection(
     return injection_mode, max_length
 
 
+def _uses_forced_thinking_behavior(injection_mode: str) -> bool:
+    return injection_mode != "auto"
+
+
 def _format_thinking_behavior(injection_mode: str) -> str:
-    body = _THINKING_BEHAVIOR_ON if injection_mode == "on" else _THINKING_BEHAVIOR_AUTO
+    body = _THINKING_BEHAVIOR_ON if _uses_forced_thinking_behavior(injection_mode) else _THINKING_BEHAVIOR_AUTO
     return f"<thinking_behavior>\n{body}\n</thinking_behavior>"
 
 

echotools-2.3.40/src/echotools/exec/fncall/protocols/entml_thinking_parse.py → echotools-2.3.43/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -92,6 +92,49 @@ class EntmlThinkingStreamFilter:
             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:
@@ -102,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
-                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))
+                if not self._feed_in_block(out):
+                    break
+                continue
+            if not self._feed_before_block(out):
                 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.40 → echotools-2.3.43}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.40 → echotools-2.3.43}/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

{echotools-2.3.40 → echotools-2.3.43}/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
@@ -128,11 +128,11 @@ def test_normalize_thinking_level(raw, expected) -> None:
 @pytest.mark.parametrize(
     "level,expected",
     [
-        ("low", 6554),
-        ("medium", 13108),
-        ("high", 32768),
-        ("xhigh", 52428),
-        ("max", 62260),
+        ("low", 12800),
+        ("medium", 25600),
+        ("high", 64000),
+        ("xhigh", 102400),
+        ("max", 134736),
         ("none", None),
         ("auto", None),
     ],
@@ -143,13 +143,13 @@ def test_default_max_thinking_length_for_level(level, expected) -> None:
 
 def test_resolve_thinking_injection_levels() -> None:
     assert resolve_thinking_injection({"thinking_level": "none"}) is None
-    assert resolve_thinking_injection({"thinking_level": "low"}) == ("on", 6554)
-    assert resolve_thinking_injection({"thinking_level": "high"}) == ("on", 32768)
+    assert resolve_thinking_injection({"thinking_level": "low"}) == ("low", 12800)
+    assert resolve_thinking_injection({"thinking_level": "high"}) == ("high", 64000)
     assert resolve_thinking_injection({"thinking_level": "auto"}) == ("auto", None)
     assert resolve_thinking_injection({
         "thinking_level": "max",
         "max_thinking_length": 1000,
-    }) == ("on", 1000)
+    }) == ("max", 1000)
 
 
 def test_thinking_prompt_off() -> None:
@@ -163,18 +163,24 @@ def test_thinking_prompt_off() -> None:
 def test_thinking_prompt_on_without_max_length() -> None:
     section = build_entml_thinking_section({"thinking_mode": "on"})
     assert "<entml:thinking_mode>on</entml:thinking_mode>" in section
-    assert "<entml:max_thinking_length>13108</entml:max_thinking_length>" in section
+    assert "<entml:max_thinking_length>25600</entml:max_thinking_length>" in section
     assert "<thinking_behavior>" in section
 
 
 def test_thinking_prompt_on_by_level() -> None:
     section = build_entml_thinking_section({"thinking_level": "low"})
-    assert "<entml:thinking_mode>on</entml:thinking_mode>" in section
-    assert "<entml:max_thinking_length>6554</entml:max_thinking_length>" in section
+    assert "<entml:thinking_mode>low</entml:thinking_mode>" in section
+    assert "<entml:max_thinking_length>12800</entml:max_thinking_length>" in section
     assert "Never skip the thinking block" in section
     assert "Your default is to think before it answers" in section
 
 
+def test_thinking_prompt_medium_by_level() -> None:
+    section = build_entml_thinking_section({"thinking_level": "medium"})
+    assert "<entml:thinking_mode>medium</entml:thinking_mode>" in section
+    assert "<entml:max_thinking_length>25600</entml:max_thinking_length>" in section
+
+
 def test_thinking_prompt_on() -> None:
     section = build_entml_thinking_section({"thinking_mode": "on"})
     assert "<entml:thinking_mode>on</entml:thinking_mode>" in section
@@ -223,6 +229,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 +349,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.40 → echotools-2.3.43}/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,