echotools 2.3.14__tar.gz → 2.3.16__tar.gz

{echotools-2.3.14 → echotools-2.3.16}/PKG-INFO

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

{echotools-2.3.14 → echotools-2.3.16}/pyproject.toml

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

{echotools-2.3.14 → echotools-2.3.16}/src/echotools/exec/fncall/protocols/entml_thinking.py

@@ -41,12 +41,12 @@ def build_entml_thinking_section(
                 "...",
                 "</function_results>",
                 "",
-                "<thinking>",
+                "<entml:thinking>",
                 "...thinking about results",
-                "</thinking>",
+                "</entml:thinking>",
                 "At the very start of your response, think carefully about whether "
-                "a `<thinking>` `</thinking>` block would be appropriate and "
-                "strongly prefer to output a thinking block if you are uncertain.",
+                "an `<entml:thinking>` `</entml:thinking>` block would be appropriate "
+                "and strongly prefer to output a thinking block if you are uncertain.",
             ]
         )
 

echotools-2.3.16/src/echotools/exec/fncall/protocols/entml_thinking_parse.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import re
+from typing import List, Tuple
+
+THINKING_BLOCK_RE = re.compile(
+    r"<entml:thinking\b[^>]*>([\s\S]*?)</entml:thinking>",
+    re.DOTALL,
+)
+
+_THINKING_OPEN_PREFIX = "<entml:thinking"
+_THINKING_CLOSE = "</entml:thinking>"
+
+
+def split_entml_thinking(text: str) -> Tuple[str, str]:
+    """从文本中剥离 <entml:thinking> 块，返回 (正文, 思考链拼接)。"""
+    if not text:
+        return "", ""
+
+    parts: List[str] = []
+
+    def _collect(match: re.Match[str]) -> str:
+        parts.append(match.group(1))
+        return ""
+
+    clean = THINKING_BLOCK_RE.sub(_collect, text)
+    thinking = "\n".join(part.strip() for part in parts if part.strip())
+    return clean.strip(), thinking
+
+
+def _split_safe_prefix(buffer: str) -> Tuple[str, str]:
+    """保留可能未闭合的 <entml:thinking 开标签尾部。"""
+    if not buffer:
+        return "", ""
+
+    open_pos = buffer.rfind(_THINKING_OPEN_PREFIX)
+    if open_pos < 0:
+        return buffer, ""
+
+    tail = buffer[open_pos:]
+    if ">" in tail and _THINKING_CLOSE not in tail:
+        return buffer, ""
+
+    close_pos = buffer.rfind(_THINKING_CLOSE)
+    if close_pos >= 0 and close_pos > open_pos:
+        return buffer, ""
+
+    if tail == _THINKING_OPEN_PREFIX[: len(tail)]:
+        return buffer[:open_pos], tail
+
+    return buffer[:open_pos], tail
+
+
+class EntmlThinkingStreamFilter:
+    """流式拆分 entml:thinking 与可见正文。"""
+
+    def __init__(self) -> None:
+        self._pending = ""
+        self._in_block = False
+        self._block_buf = ""
+
+    def feed(self, chunk: str) -> List[Tuple[str, str]]:
+        """返回 [(kind, text), ...]，kind 为 content 或 thinking。"""
+        if not chunk:
+            return []
+
+        self._pending += chunk
+        out: List[Tuple[str, str]] = []
+
+        while self._pending:
+            if self._in_block:
+                close_at = self._pending.find(_THINKING_CLOSE)
+                if close_at < 0:
+                    self._block_buf += self._pending
+                    self._pending = ""
+                    break
+                self._block_buf += self._pending[:close_at]
+                thinking = self._block_buf.strip()
+                if thinking:
+                    out.append(("thinking", thinking))
+                self._block_buf = ""
+                self._in_block = False
+                self._pending = self._pending[close_at + len(_THINKING_CLOSE) :]
+                continue
+
+            open_at = self._pending.find(_THINKING_OPEN_PREFIX)
+            if open_at < 0:
+                safe, self._pending = _split_safe_prefix(self._pending)
+                if safe:
+                    out.append(("content", safe))
+                break
+
+            if open_at > 0:
+                prefix = self._pending[:open_at]
+                out.append(("content", prefix))
+                self._pending = self._pending[open_at:]
+
+            gt = self._pending.find(">")
+            if gt < 0:
+                break
+
+            self._in_block = True
+            self._pending = self._pending[gt + 1 :]
+
+        return out
+
+    def finalize(self) -> List[Tuple[str, str]]:
+        out: List[Tuple[str, str]] = []
+        if self._in_block:
+            thinking = (self._block_buf + self._pending).strip()
+            if thinking:
+                out.append(("thinking", thinking))
+        elif self._pending:
+            content, thinking = split_entml_thinking(self._pending)
+            if thinking:
+                out.append(("thinking", thinking))
+            if content:
+                out.append(("content", content))
+        self._pending = ""
+        self._block_buf = ""
+        self._in_block = False
+        return out

{echotools-2.3.14 → echotools-2.3.16}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.14 → echotools-2.3.16}/src/echotools.egg-info/SOURCES.txt

@@ -58,6 +58,7 @@ 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_thinking.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/shared/__init__.py
@@ -150,6 +151,7 @@ src/tests/test_dispatch.py
 src/tests/test_dispatch_extended.py
 src/tests/test_dispatch_race.py
 src/tests/test_entml_protocol.py
+src/tests/test_entml_thinking_parse.py
 src/tests/test_entml_tools.py
 src/tests/test_errors.py
 src/tests/test_errors_common.py

{echotools-2.3.14 → echotools-2.3.16}/src/tests/test_entml_protocol.py

@@ -60,9 +60,8 @@ def test_inject_with_thinking_options_only_when_declared() -> None:
     )[0]["content"]
     assert "<entml:thinking_mode>interleaved</entml:thinking_mode>" in with_opts
     assert "<entml:max_thinking_length>22000</entml:max_thinking_length>" in with_opts
-    assert "<thinking>" in with_opts
+    assert "<entml:thinking>" in with_opts
     assert "At the very start of your response" in with_opts
-    assert "<entml:thinking>" not in with_opts
 
 
 def test_build_entml_thinking_section_empty_without_options() -> None:

echotools-2.3.16/src/tests/test_entml_thinking_parse.py

@@ -0,0 +1,27 @@
+from echotools.exec.fncall.protocols.entml_thinking_parse import (
+    EntmlThinkingStreamFilter,
+    split_entml_thinking,
+)
+
+
+def test_split_entml_thinking() -> None:
+    text = (
+        "prefix\n<entml:thinking>\nstep one\n</entml:thinking>\n"
+        "answer tail"
+    )
+    content, thinking = split_entml_thinking(text)
+    assert thinking == "step one"
+    assert "prefix" in content
+    assert "answer tail" in content
+    assert "<entml:thinking>" not in content
+
+
+def test_entml_thinking_stream_filter() -> None:
+    filt = EntmlThinkingStreamFilter()
+    parts = []
+    for chunk in ["hello ", "<entml:thinking>rea", "son</entml:thinking> world"]:
+        parts.extend(filt.feed(chunk))
+    parts.extend(filt.finalize())
+    kinds = {kind for kind, _ in parts}
+    assert "thinking" in kinds
+    assert "content" in kinds