echotools 2.3.60__tar.gz → 2.3.62__tar.gz

{echotools-2.3.60 → echotools-2.3.62}/PKG-INFO

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

{echotools-2.3.60 → echotools-2.3.62}/pyproject.toml

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

{echotools-2.3.60 → echotools-2.3.62}/src/echotools/exec/fncall/parsers/stream.py

@@ -12,12 +12,12 @@ from echotools.exec.protocol.base import ToolProtocol
 
 
 # 懒导入：仅 entml 协议需要
-def _make_thinking_filter(protocol: ToolProtocol):
+def _make_thinking_filter(protocol: ToolProtocol, *, thinking_enabled: bool = True):
     if getattr(protocol, "id", None) == "entml":
         from echotools.exec.fncall.protocols.entml_think.parse import (
             EntmlThinkingStreamFilter,
         )
-        return EntmlThinkingStreamFilter()
+        return EntmlThinkingStreamFilter(thinking_enabled=thinking_enabled)
     return None
 
 
@@ -40,9 +40,13 @@ class FncallStreamParser:
         self,
         protocol: ToolProtocol,
         tools: Optional[List[Dict[str, Any]]] = None,
+        protocol_options: Optional[Dict[str, Any]] = None,
     ) -> None:
         self._protocol = protocol
         self._tools = tools
+        from echotools.exec.fncall.protocols.entml_think.core import is_thinking_enabled
+
+        self._thinking_enabled = is_thinking_enabled(protocol_options)
         self._raw_buf: str = ""
         self._text_parts: List[str] = []
         self._waiting_tail: str = ""
@@ -51,7 +55,9 @@ class FncallStreamParser:
         self._state: str = self.WAITING_FOR_TAG
         self._finalized_result: Optional[Tuple[str, List[Dict[str, Any]]]] = None
         self._thinking_parts: List[str] = []
-        self._thinking_filter = _make_thinking_filter(protocol)
+        self._thinking_filter = _make_thinking_filter(
+            protocol, thinking_enabled=self._thinking_enabled
+        )
         self._emitted_invoke_count: int = 0
         self._json_stream_encoder = None
         self._pending_stream_deltas: Deque[Tuple[str, str]] = deque()
@@ -298,7 +304,9 @@ class FncallStreamParser:
                 from echotools.exec.fncall.protocols.entml_think.parse import (
                     invoke_index_inside_unclosed_thinking,
                 )
-                if invoke_index_inside_unclosed_thinking(combined, pos):
+                if invoke_index_inside_unclosed_thinking(
+                    combined, pos, thinking_enabled=self._thinking_enabled
+                ):
                     self._feed_waiting_thinking_plain(combined)
                     return
             if pos > 0:
@@ -314,7 +322,9 @@ class FncallStreamParser:
             from echotools.exec.fncall.protocols.entml_think.parse import (
                 has_unclosed_entml_thinking,
             )
-            if has_unclosed_entml_thinking(combined):
+            if has_unclosed_entml_thinking(
+                combined, thinking_enabled=self._thinking_enabled
+            ):
                 self._feed_waiting_thinking_plain(combined)
                 return
 
@@ -633,7 +643,9 @@ class FncallStreamParser:
             from echotools.exec.fncall.protocols.entml_think.parse import (
                 split_entml_thinking,
             )
-            clean_text, more_thinking = split_entml_thinking(clean_text)
+            clean_text, more_thinking = split_entml_thinking(
+                clean_text, thinking_enabled=self._thinking_enabled
+            )
             if more_thinking:
                 self._thinking_parts.append(more_thinking)
 

{echotools-2.3.60 → echotools-2.3.62}/src/echotools/exec/fncall/protocols/entml_think/__init__.py

@@ -2,6 +2,7 @@
 
 from echotools.exec.fncall.protocols.entml_think.core import (
     build_entml_thinking_section,
+    is_thinking_enabled,
     parse_max_thinking_length,
 )
 from echotools.exec.fncall.protocols.entml_think.hist import (
@@ -24,6 +25,7 @@ __all__ = [
     "extract_reasoning_text",
     "format_entml_thinking_history_block",
     "has_unclosed_entml_thinking",
+    "is_thinking_enabled",
     "parse_include_thinking_in_history",
     "parse_interleaved_history",
     "parse_max_thinking_length",

{echotools-2.3.60 → echotools-2.3.62}/src/echotools/exec/fncall/protocols/entml_think/core.py

@@ -159,6 +159,16 @@ def resolve_thinking_injection(
     return injection_mode, max_length
 
 
+def is_thinking_enabled(protocol_options: Optional[Dict[str, Any]] = None) -> bool:
+    """是否开启思考模式（容错与 plain ``<thinking>`` 仅在此为 True 时生效）。
+
+    未传 ``protocol_options`` 时视为已开启（兼容旧调用）；显式 ``off`` / ``none`` 时关闭。
+    """
+    if protocol_options is None:
+        return True
+    return resolve_thinking_injection(protocol_options) is not None
+
+
 def _uses_forced_thinking_behavior(injection_mode: str) -> bool:
     return injection_mode != "auto"
 

{echotools-2.3.60 → echotools-2.3.62}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -16,6 +16,7 @@ THINKING_BLOCK_RE = re.compile(
 )
 
 _THINKING_OPEN_PREFIX = "<entml:thinking"
+_PLAIN_THINKING_OPEN_PREFIX = "<thinking"
 _THINKING_CLOSE = "</entml:thinking>"
 _FAULT_THINKING_CLOSE = "</thinking>"
 # 与 thinking 共享 `<entml:` 前缀的其它标签：歧义 holdback 应交由工具流式状态机处理
@@ -116,6 +117,95 @@ def find_ambiguous_entml_tool_prefix(buffer: str) -> int:
     return earliest
 
 
+def _find_plain_thinking_open(text: str, start: int = 0) -> int:
+    """返回 plain ``<thinking>`` 开标签起始下标（``<entml:thinking>`` 内不含此子串）。"""
+    return text.find(_PLAIN_THINKING_OPEN_PREFIX, start)
+
+
+def _find_earliest_thinking_open(
+    text: str,
+    start: int = 0,
+    *,
+    thinking_enabled: bool = True,
+) -> Tuple[int, bool]:
+    """返回 ``(开标签下标, 是否 plain)``；无则 ``(-1, False)``。"""
+    entml_at = text.find(_THINKING_OPEN_PREFIX, start)
+    if not thinking_enabled:
+        if entml_at < 0:
+            return -1, False
+        return entml_at, False
+    plain_at = _find_plain_thinking_open(text, start)
+    if entml_at < 0 and plain_at < 0:
+        return -1, False
+    if entml_at < 0:
+        return plain_at, True
+    if plain_at < 0:
+        return entml_at, False
+    if plain_at < entml_at:
+        return plain_at, True
+    return entml_at, False
+
+
+def _find_thinking_close(
+    text: str,
+    body_start: int,
+    *,
+    opened_plain: bool,
+    thinking_enabled: bool = True,
+) -> Tuple[int, int]:
+    """返回 ``(闭标签下标, 闭标签长度)``；未找到则 ``(-1, 0)``。"""
+    if not thinking_enabled:
+        close_at = text.find(_THINKING_CLOSE, body_start)
+        if close_at >= 0:
+            return close_at, len(_THINKING_CLOSE)
+        return -1, 0
+
+    if opened_plain:
+        entml_close = text.find(_THINKING_CLOSE, body_start)
+        fault_close = text.find(_FAULT_THINKING_CLOSE, body_start)
+        candidates: List[Tuple[int, int]] = []
+        if entml_close >= 0:
+            candidates.append((entml_close, len(_THINKING_CLOSE)))
+        if fault_close >= 0:
+            candidates.append((fault_close, len(_FAULT_THINKING_CLOSE)))
+        if not candidates:
+            return -1, 0
+        close_at, close_len = min(candidates, key=lambda item: item[0])
+        return close_at, close_len
+
+    entml_close = text.find(_THINKING_CLOSE, body_start)
+    fault_close = text.find(_FAULT_THINKING_CLOSE, body_start)
+    if entml_close >= 0 and (fault_close < 0 or entml_close <= fault_close):
+        return entml_close, len(_THINKING_CLOSE)
+    if fault_close < 0:
+        return -1, 0
+
+    after_fault = fault_close + len(_FAULT_THINKING_CLOSE)
+    invoke_rel = find_complete_entml_invoke_open(text[after_fault:])
+    entml_after = text.find(_THINKING_CLOSE, after_fault)
+    if invoke_rel >= 0:
+        invoke_abs = after_fault + invoke_rel
+        if entml_after < 0 or invoke_abs < entml_after:
+            return fault_close, len(_FAULT_THINKING_CLOSE)
+    if entml_after >= 0:
+        return entml_after, len(_THINKING_CLOSE)
+    return -1, 0
+
+
+def _hold_thinking_open_prefixes(
+    buffer: str,
+    *,
+    thinking_enabled: bool = True,
+) -> Tuple[str, str]:
+    """hold ``<entml:thinking`` 或 plain ``<thinking`` 的真前缀。"""
+    safe, hold = _hold_prefix(buffer, _THINKING_OPEN_PREFIX)
+    if hold:
+        return safe, hold
+    if thinking_enabled:
+        return _hold_prefix(safe, _PLAIN_THINKING_OPEN_PREFIX)
+    return safe, ""
+
+
 def _hold_ambiguous_tool_markup(buffer: str) -> Tuple[str, str]:
     """thinking 块内：hold 可能长成真实工具调用的 markup（非 prose ``<entml:invoke>`` 提及）。"""
     if not buffer:
@@ -143,68 +233,125 @@ def _hold_ambiguous_tool_markup(buffer: str) -> Tuple[str, str]:
     return buffer, ""
 
 
-def has_unclosed_entml_thinking(text: str) -> bool:
-    """buffer 中是否存在尚未闭合的 <entml:thinking> 块（含开标签未收齐）。"""
+def has_unclosed_entml_thinking(
+    text: str,
+    *,
+    thinking_enabled: bool = True,
+) -> bool:
+    """buffer 中是否存在尚未闭合的 thinking 块（含开标签未收齐）。"""
     if not text:
         return False
     i = 0
     while i < len(text):
-        open_at = text.find(_THINKING_OPEN_PREFIX, i)
+        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 True
-        close_at = text.find(_THINKING_CLOSE, gt + 1)
+        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
-        i = close_at + len(_THINKING_CLOSE)
+        i = close_at + close_len
     max_keep = len(_THINKING_OPEN_PREFIX) - 1
+    if thinking_enabled:
+        max_keep = max(max_keep, len(_PLAIN_THINKING_OPEN_PREFIX) - 1)
     check_len = min(len(text), max_keep)
     for length in range(check_len, 0, -1):
         suffix = text[-length:]
-        if not (
-            _THINKING_OPEN_PREFIX.startswith(suffix) and suffix != _THINKING_OPEN_PREFIX
+        if (
+            _THINKING_OPEN_PREFIX.startswith(suffix)
+            and suffix != _THINKING_OPEN_PREFIX
         ):
-            continue
-        # `<e` / `<entml:` 等对 invoke 同样是真前缀 → 不在此抢占
-        if any(other.startswith(suffix) for other in _AMBIGUOUS_ENTML_PREFIXES):
-            continue
-        return True
+            if any(other.startswith(suffix) for other in _AMBIGUOUS_ENTML_PREFIXES):
+                continue
+            return True
+        if thinking_enabled and (
+            _PLAIN_THINKING_OPEN_PREFIX.startswith(suffix)
+            and suffix != _PLAIN_THINKING_OPEN_PREFIX
+        ):
+            return True
     return False
 
 
-def invoke_index_inside_unclosed_thinking(text: str, invoke_at: int) -> bool:
-    """``invoke_at`` 是否落在尚未正式 ``</entml:thinking>`` 闭合的块内。
-
-    已出现容错 ``</thinking>`` 且 invoke 在其后的段落，视为 thinking 外。
-    """
+def invoke_index_inside_unclosed_thinking(
+    text: str,
+    invoke_at: int,
+    *,
+    thinking_enabled: bool = True,
+) -> bool:
+    """``invoke_at`` 是否落在尚未闭合的 thinking 块内。"""
     if invoke_at < 0:
         return False
-    think_open = text.find(_THINKING_OPEN_PREFIX)
+    think_open, opened_plain = _find_earliest_thinking_open(
+        text, thinking_enabled=thinking_enabled
+    )
     if think_open < 0 or invoke_at <= think_open:
         return False
-    entml_close = text.find(_THINKING_CLOSE, think_open)
-    if entml_close >= 0:
-        return invoke_at < entml_close
-    fault_at = text.find(_FAULT_THINKING_CLOSE, think_open)
-    if fault_at >= 0:
-        return invoke_at < fault_at + len(_FAULT_THINKING_CLOSE)
-    return True
+    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
 
 
-def split_entml_thinking(text: str) -> Tuple[str, str]:
-    """从文本中剥离 <entml:thinking> 块，返回 (正文, 思考链拼接)。"""
+def split_entml_thinking(
+    text: str,
+    *,
+    thinking_enabled: bool = True,
+) -> Tuple[str, str]:
+    """从文本中剥离 thinking 块，返回 (正文, 思考链拼接)。"""
     if not text:
         return "", ""
 
     parts: List[str] = []
+    clean_parts: List[str] = []
+    i = 0
+    while i < len(text):
+        open_at, opened_plain = _find_earliest_thinking_open(
+            text, i, thinking_enabled=thinking_enabled
+        )
+        if open_at < 0:
+            clean_parts.append(text[i:])
+            break
+
+        clean_parts.append(text[i:open_at])
+        gt = text.find(">", open_at)
+        if gt < 0:
+            clean_parts.append(text[open_at:])
+            break
+
+        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:
+            clean_parts.append(text[open_at:])
+            break
 
-    def _collect(match: re.Match[str]) -> str:
-        parts.append(match.group(1))
-        return ""
+        parts.append(text[body_start:close_at])
+        i = close_at + close_len
 
-    clean = THINKING_BLOCK_RE.sub(_collect, text)
+    clean = "".join(clean_parts)
     thinking = "\n".join(part.strip() for part in parts if part.strip())
     return strip_orphan_thinking_close_prefix(clean.strip()), thinking
 
@@ -241,9 +388,11 @@ class EntmlThinkingStreamFilter:
     块内正文在收到时即增量输出 thinking，无需等闭合标签。
     """
 
-    def __init__(self) -> None:
+    def __init__(self, *, thinking_enabled: bool = True) -> None:
+        self._thinking_enabled = thinking_enabled
         self._pending = ""
         self._in_block = False
+        self._opened_plain = False
         # 当前 thinking 块是否已输出过任何内容（用于首片去前导空白）
         self._thinking_started = False
         # 见到 ``</thinking>`` 后暂存，仅当后续出现 invoke 才视为闭合；否则当纯文本
@@ -253,20 +402,25 @@ class EntmlThinkingStreamFilter:
     def clear_invoke_handoff_state(self) -> None:
         """invoke 已交给正文/工具解析后，结束 thinking / fault 观察状态。"""
         self._in_block = False
+        self._opened_plain = False
         self._fault_watch = False
         self._fault_buffer = ""
         self._thinking_started = False
 
     def in_open_thinking(self) -> bool:
-        """思考块已开始且尚未收到 ``</entml:thinking>``（含开/闭标签分片 hold）。"""
+        """思考块已开始且尚未闭合（含开/闭标签分片 hold）。"""
         if self._in_block or self._fault_watch:
             return True
-        open_at = self._pending.find(_THINKING_OPEN_PREFIX)
+        open_at, _ = _find_earliest_thinking_open(
+            self._pending, thinking_enabled=self._thinking_enabled
+        )
         if open_at >= 0:
             gt = self._pending.find(">", open_at)
             if gt < 0:
                 return True
-        _, hold = _hold_prefix(self._pending, _THINKING_OPEN_PREFIX)
+        _, hold = _hold_thinking_open_prefixes(
+            self._pending, thinking_enabled=self._thinking_enabled
+        )
         if hold:
             return True
         return False
@@ -279,6 +433,7 @@ class EntmlThinkingStreamFilter:
         if invoke_at < len(_FAULT_THINKING_CLOSE):
             return False
         self._in_block = False
+        self._opened_plain = False
         self._fault_watch = False
         self._thinking_started = False
         self._pending = self._fault_buffer[len(_FAULT_THINKING_CLOSE) :]
@@ -296,6 +451,7 @@ class EntmlThinkingStreamFilter:
         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) :]
@@ -323,12 +479,15 @@ class EntmlThinkingStreamFilter:
                     out.append(("thinking", emitted))
             out.append(("content", invoke_block))
             self._in_block = False
+            self._opened_plain = False
             self._fault_watch = False
             self._fault_buffer = ""
             self._thinking_started = False
             rest = after.lstrip()
             if rest.startswith(_THINKING_CLOSE):
                 rest = rest[len(_THINKING_CLOSE) :].lstrip()
+            if rest.startswith(_FAULT_THINKING_CLOSE):
+                rest = rest[len(_FAULT_THINKING_CLOSE) :].lstrip()
             self._pending = rest
             return True
         return False
@@ -361,6 +520,7 @@ class EntmlThinkingStreamFilter:
                 if emitted:
                     out.append(("thinking", emitted))
             self._in_block = False
+            self._opened_plain = False
             self._fault_watch = False
             self._fault_buffer = ""
             self._thinking_started = False
@@ -371,8 +531,19 @@ class EntmlThinkingStreamFilter:
             return True
 
         fault_at = self._pending.find(_FAULT_THINKING_CLOSE)
-        if fault_at >= 0:
+        if fault_at >= 0 and self._thinking_enabled:
             before = self._pending[:fault_at]
+            if self._opened_plain:
+                emitted = self._emit_thinking_piece(before)
+                if emitted:
+                    out.append(("thinking", emitted))
+                self._in_block = False
+                self._opened_plain = False
+                self._fault_watch = False
+                self._fault_buffer = ""
+                self._thinking_started = False
+                self._pending = self._pending[fault_at + len(_FAULT_THINKING_CLOSE) :]
+                return True
             emitted = self._emit_thinking_piece(before)
             if emitted:
                 out.append(("thinking", emitted))
@@ -391,7 +562,7 @@ class EntmlThinkingStreamFilter:
             return False
 
         safe, hold = _hold_prefix(self._pending, _THINKING_CLOSE)
-        if not hold:
+        if not hold and self._thinking_enabled:
             safe, hold = _hold_prefix(safe, _FAULT_THINKING_CLOSE)
         if safe:
             emitted = self._emit_thinking_piece(safe)
@@ -402,9 +573,13 @@ class EntmlThinkingStreamFilter:
 
     def _feed_before_block(self, out: List[Tuple[str, str]]) -> bool:
         """开标签之前或尚未进入块；返回 False 表示应退出 feed 主循环。"""
-        open_at = self._pending.find(_THINKING_OPEN_PREFIX)
+        open_at, opened_plain = _find_earliest_thinking_open(
+            self._pending, thinking_enabled=self._thinking_enabled
+        )
         if open_at < 0:
-            safe, self._pending = _hold_prefix(self._pending, _THINKING_OPEN_PREFIX)
+            safe, self._pending = _hold_thinking_open_prefixes(
+                self._pending, thinking_enabled=self._thinking_enabled
+            )
             if safe:
                 out.append(("content", safe))
             return False
@@ -418,6 +593,7 @@ class EntmlThinkingStreamFilter:
             return False
 
         self._in_block = True
+        self._opened_plain = opened_plain
         self._thinking_started = False
         self._pending = self._pending[gt + 1 :]
         return True
@@ -471,6 +647,7 @@ class EntmlThinkingStreamFilter:
                 self._fault_buffer = ""
                 self._fault_watch = False
                 self._in_block = False
+                self._opened_plain = False
                 self._thinking_started = False
         if self._in_block:
             if not self._try_emit_actionable_invoke_from_in_block(out):
@@ -479,9 +656,12 @@ class EntmlThinkingStreamFilter:
                     out.append(("thinking", emitted))
                 self._pending = ""
             self._in_block = False
+            self._opened_plain = False
             self._thinking_started = False
         if self._pending:
-            content, thinking = split_entml_thinking(self._pending)
+            content, thinking = split_entml_thinking(
+                self._pending, thinking_enabled=self._thinking_enabled
+            )
             if thinking:
                 out.append(("thinking", thinking))
             if content:
@@ -490,6 +670,7 @@ class EntmlThinkingStreamFilter:
                 out.append(("content", self._pending))
         self._pending = ""
         self._in_block = False
+        self._opened_plain = False
         self._fault_watch = False
         self._fault_buffer = ""
         self._thinking_started = False

{echotools-2.3.60 → echotools-2.3.62}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.60 → echotools-2.3.62}/src/tests/test_entml_thinking_parse.py

@@ -92,3 +92,62 @@ def test_entml_thinking_hold_close_prefix() -> None:
     content = "".join(t for k, t in parts if k == "content")
     assert thinking == "ab"
     assert content == "cd"
+
+
+def test_plain_thinking_open_entml_close_batch() -> None:
+    text = "<thinking>\nplan step\n</entml:thinking>\nanswer"
+    content, thinking = split_entml_thinking(text)
+    assert thinking == "plan step"
+    assert "answer" in content
+    assert "<thinking>" not in content
+
+
+def test_plain_thinking_open_fault_close_batch() -> None:
+    text = "<thinking>\nplan step\n</thinking>\nanswer"
+    content, thinking = split_entml_thinking(text)
+    assert thinking == "plan step"
+    assert "answer" in content
+
+
+def test_plain_thinking_stream_entml_close() -> None:
+    filt = EntmlThinkingStreamFilter()
+    parts = []
+    for chunk in ["<thinking>\nplan", "\n</entml:thinking>\n", "hello"]:
+        parts.extend(filt.feed(chunk))
+    parts.extend(filt.finalize())
+    thinking = "".join(t for k, t in parts if k == "thinking")
+    content = "".join(t for k, t in parts if k == "content")
+    assert thinking.strip() == "plan"
+    assert "hello" in content
+
+
+def test_plain_thinking_stream_fault_close() -> None:
+    filt = EntmlThinkingStreamFilter()
+    parts = []
+    for chunk in ["<thinking>\nplan\n</thinking>\n", "hello"]:
+        parts.extend(filt.feed(chunk))
+    parts.extend(filt.finalize())
+    thinking = "".join(t for k, t in parts if k == "thinking")
+    content = "".join(t for k, t in parts if k == "content")
+    assert thinking.strip() == "plan"
+    assert "hello" in content
+    assert not filt.in_open_thinking()
+
+
+def test_is_thinking_enabled() -> None:
+    from echotools.exec.fncall.protocols.entml_think.core import is_thinking_enabled
+
+    assert is_thinking_enabled(None)
+    assert is_thinking_enabled({"thinking_mode": "on"})
+    assert is_thinking_enabled({"thinking_mode": "auto"})
+    assert not is_thinking_enabled({"thinking_mode": "off"})
+    assert not is_thinking_enabled({"thinking_level": "none"})
+
+
+def test_plain_thinking_requires_thinking_enabled_batch() -> None:
+    text = "<thinking>\nplan\n</thinking>\nanswer"
+    _, thinking_on = split_entml_thinking(text, thinking_enabled=True)
+    content_off, thinking_off = split_entml_thinking(text, thinking_enabled=False)
+    assert thinking_on == "plan"
+    assert thinking_off == ""
+    assert "<thinking>" in content_off