echotools 2.3.61__tar.gz → 2.3.62__tar.gz

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

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

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

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

{echotools-2.3.61 → 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.61 → 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.61 → 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.61 → echotools-2.3.62}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -122,9 +122,18 @@ def _find_plain_thinking_open(text: str, start: int = 0) -> int:
     return text.find(_PLAIN_THINKING_OPEN_PREFIX, start)
 
 
-def _find_earliest_thinking_open(text: str, start: int = 0) -> Tuple[int, bool]:
+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
@@ -142,8 +151,15 @@ def _find_thinking_close(
     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)
@@ -176,12 +192,18 @@ def _find_thinking_close(
     return -1, 0
 
 
-def _hold_thinking_open_prefixes(buffer: str) -> Tuple[str, str]:
+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
-    return _hold_prefix(safe, _PLAIN_THINKING_OPEN_PREFIX)
+    if thinking_enabled:
+        return _hold_prefix(safe, _PLAIN_THINKING_OPEN_PREFIX)
+    return safe, ""
 
 
 def _hold_ambiguous_tool_markup(buffer: str) -> Tuple[str, str]:
@@ -211,13 +233,19 @@ def _hold_ambiguous_tool_markup(buffer: str) -> Tuple[str, str]:
     return buffer, ""
 
 
-def has_unclosed_entml_thinking(text: str) -> bool:
+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, opened_plain = _find_earliest_thinking_open(text, 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)
@@ -225,12 +253,17 @@ def has_unclosed_entml_thinking(text: str) -> bool:
             return True
         body_start = gt + 1
         close_at, close_len = _find_thinking_close(
-            text, body_start, opened_plain=opened_plain
+            text,
+            body_start,
+            opened_plain=opened_plain,
+            thinking_enabled=thinking_enabled,
         )
         if close_at < 0:
             return True
         i = close_at + close_len
-    max_keep = max(len(_THINKING_OPEN_PREFIX), len(_PLAIN_THINKING_OPEN_PREFIX)) - 1
+    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:]
@@ -241,7 +274,7 @@ def has_unclosed_entml_thinking(text: str) -> bool:
             if any(other.startswith(suffix) for other in _AMBIGUOUS_ENTML_PREFIXES):
                 continue
             return True
-        if (
+        if thinking_enabled and (
             _PLAIN_THINKING_OPEN_PREFIX.startswith(suffix)
             and suffix != _PLAIN_THINKING_OPEN_PREFIX
         ):
@@ -249,11 +282,18 @@ def has_unclosed_entml_thinking(text: str) -> bool:
     return False
 
 
-def invoke_index_inside_unclosed_thinking(text: str, invoke_at: int) -> bool:
+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, opened_plain = _find_earliest_thinking_open(text)
+    think_open, opened_plain = _find_earliest_thinking_open(
+        text, thinking_enabled=thinking_enabled
+    )
     if think_open < 0 or invoke_at <= think_open:
         return False
     gt = text.find(">", think_open)
@@ -261,14 +301,21 @@ def invoke_index_inside_unclosed_thinking(text: str, invoke_at: int) -> bool:
         return True
     body_start = gt + 1
     close_at, close_len = _find_thinking_close(
-        text, body_start, opened_plain=opened_plain
+        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]:
+def split_entml_thinking(
+    text: str,
+    *,
+    thinking_enabled: bool = True,
+) -> Tuple[str, str]:
     """从文本中剥离 thinking 块，返回 (正文, 思考链拼接)。"""
     if not text:
         return "", ""
@@ -277,7 +324,9 @@ def split_entml_thinking(text: str) -> Tuple[str, str]:
     clean_parts: List[str] = []
     i = 0
     while i < len(text):
-        open_at, opened_plain = _find_earliest_thinking_open(text, i)
+        open_at, opened_plain = _find_earliest_thinking_open(
+            text, i, thinking_enabled=thinking_enabled
+        )
         if open_at < 0:
             clean_parts.append(text[i:])
             break
@@ -290,7 +339,10 @@ def split_entml_thinking(text: str) -> Tuple[str, str]:
 
         body_start = gt + 1
         close_at, close_len = _find_thinking_close(
-            text, body_start, opened_plain=opened_plain
+            text,
+            body_start,
+            opened_plain=opened_plain,
+            thinking_enabled=thinking_enabled,
         )
         if close_at < 0:
             clean_parts.append(text[open_at:])
@@ -336,7 +388,8 @@ 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
@@ -358,12 +411,16 @@ class EntmlThinkingStreamFilter:
         """思考块已开始且尚未闭合（含开/闭标签分片 hold）。"""
         if self._in_block or self._fault_watch:
             return True
-        open_at, _ = _find_earliest_thinking_open(self._pending)
+        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_thinking_open_prefixes(self._pending)
+        _, hold = _hold_thinking_open_prefixes(
+            self._pending, thinking_enabled=self._thinking_enabled
+        )
         if hold:
             return True
         return False
@@ -474,7 +531,7 @@ 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)
@@ -505,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)
@@ -516,9 +573,13 @@ class EntmlThinkingStreamFilter:
 
     def _feed_before_block(self, out: List[Tuple[str, str]]) -> bool:
         """开标签之前或尚未进入块；返回 False 表示应退出 feed 主循环。"""
-        open_at, opened_plain = _find_earliest_thinking_open(self._pending)
+        open_at, opened_plain = _find_earliest_thinking_open(
+            self._pending, thinking_enabled=self._thinking_enabled
+        )
         if open_at < 0:
-            safe, self._pending = _hold_thinking_open_prefixes(self._pending)
+            safe, self._pending = _hold_thinking_open_prefixes(
+                self._pending, thinking_enabled=self._thinking_enabled
+            )
             if safe:
                 out.append(("content", safe))
             return False
@@ -598,7 +659,9 @@ class EntmlThinkingStreamFilter:
             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:

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

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

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

@@ -132,3 +132,22 @@ def test_plain_thinking_stream_fault_close() -> None:
     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

{echotools-2.3.61 → echotools-2.3.62}/src/tests/test_fncall_stream_thinking.py

@@ -328,3 +328,35 @@ def test_entml_open_fault_close_then_invoke_still_works(chunk: int = 3) -> None:
     clean, calls = parser.finalize()
     assert len(calls) == 1
     assert "plan" in parser.partial_thinking
+
+
+@pytest.mark.parametrize("chunk", [1, 5, 17])
+def test_thinking_disabled_plain_open_stays_visible(chunk: int) -> None:
+    """未开思考时 plain ``<thinking>`` 不得进入思考链。"""
+    parser = FncallStreamParser(
+        protocol=get_protocol("entml"),
+        tools=TOOLS,
+        protocol_options={"thinking_mode": "off"},
+    )
+    text = "<thinking>\nplan\n</thinking>\nvisible\n"
+    for i in range(0, len(text), chunk):
+        parser.feed(text[i : i + chunk])
+    clean, calls = parser.finalize()
+    assert not calls
+    assert not parser.partial_thinking
+    assert "<thinking>" in parser.partial_text or "plan" in parser.partial_text
+    assert "visible" in clean
+
+
+def test_thinking_disabled_fault_close_not_applied() -> None:
+    """未开思考时 ``</thinking>`` 不得作为 entml 块的 fault 闭合。"""
+    parser = FncallStreamParser(
+        protocol=get_protocol("entml"),
+        tools=TOOLS,
+        protocol_options={"thinking_mode": "off"},
+    )
+    text = f"<entml:thinking>\nplan\n</thinking>\n{INVOKE}"
+    parser.feed(text)
+    clean, calls = parser.finalize()
+    assert len(calls) == 1
+    assert "plan" not in parser.partial_thinking or "</thinking>" in parser.partial_thinking