echotools 2.3.39__tar.gz → 2.3.40__tar.gz

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

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

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

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

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

@@ -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_thinking_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
 

{echotools-2.3.39 → echotools-2.3.40}/src/echotools/exec/fncall/protocols/entml_thinking_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,20 @@ 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(self, chunk: str) -> List[Tuple[str, str]]:
         """返回 [(kind, text), ...]，kind 为 content 或 thinking。"""
         if not chunk:

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

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

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

@@ -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.40}/src/tests/test_entml_thinking_parse.py

@@ -1,5 +1,6 @@
 from echotools.exec.fncall.protocols.entml_thinking_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 = []

echotools-2.3.40/src/tests/test_fncall_stream_thinking.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from echotools.exec.fncall import get_protocol
+from echotools.exec.fncall.parsers.stream import FncallStreamParser
+from echotools.exec.fncall.protocols.entml_thinking_parse import (
+    EntmlThinkingStreamFilter,
+    has_unclosed_entml_thinking,
+    split_entml_thinking,
+)
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "parameters": {
+                "type": "object",
+                "properties": {"city": {"type": "string"}},
+                "required": ["city"],
+            },
+        },
+    }
+]
+
+INVOKE = (
+    '<entml:invoke name="get_weather">'
+    '<entml:parameter name="city">Hangzhou</entml:parameter>'
+    "</entml:invoke>"
+)
+
+
+def test_has_unclosed_entml_thinking() -> None:
+    assert not has_unclosed_entml_thinking("")
+    assert not has_unclosed_entml_thinking("hello")
+    assert has_unclosed_entml_thinking("<entml:thinking>\nstep")
+    assert has_unclosed_entml_thinking("<entml:thinking>\nstep</entml:think")
+    assert not has_unclosed_entml_thinking(
+        "<entml:thinking>\nstep\n</entml:thinking>\nanswer"
+    )
+
+
+def test_in_open_thinking_hold_open_tag() -> None:
+    filt = EntmlThinkingStreamFilter()
+    assert not filt.in_open_thinking()
+    filt.feed("prefix <entml:think")
+    assert filt.in_open_thinking()
+
+
+def test_split_entml_thinking_ignores_unclosed_block() -> None:
+    text = "<entml:thinking>still going\n" + INVOKE
+    content, thinking = split_entml_thinking(text)
+    assert thinking == ""
+    assert INVOKE in content
+
+
+def test_invoke_inside_unclosed_thinking_not_parsed_as_tool() -> None:
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    stream = f"<entml:thinking>\nplan {INVOKE}\n"
+    for i in range(0, len(stream), 7):
+        parser.feed(stream[i : i + 7])
+    assert not parser.has_calls
+    assert INVOKE in parser.partial_thinking
+    clean, calls = parser.finalize()
+    assert not calls
+    assert INVOKE not in clean
+
+
+def test_invoke_after_thinking_close_is_parsed() -> None:
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    text = f"<entml:thinking>ok</entml:thinking>\n\n{INVOKE}"
+    parser.feed(text)
+    assert parser.has_calls
+    clean, calls = parser.finalize()
+    assert len(calls) == 1
+    assert calls[0]["function"]["name"] == "get_weather"
+    assert "Hangzhou" in calls[0]["function"]["arguments"]
+
+
+def test_thinking_close_and_invoke_in_one_chunk() -> None:
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    chunks = ["<entml:thinking>reason</entml:thinking>", INVOKE]
+    for chunk in chunks:
+        parser.feed(chunk)
+    clean, calls = parser.finalize()
+    assert parser.partial_thinking.strip() == "reason"
+    assert len(calls) == 1
+    assert "reason" not in clean or clean.strip() == ""
+
+
+def test_no_thinking_invoke_still_works() -> None:
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    parser.feed(f"Sure.\n{INVOKE}")
+    clean, calls = parser.finalize()
+    assert len(calls) == 1
+    assert "Sure" in clean
+
+
+def test_stream_thinking_incremental_before_close() -> None:
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    parser.feed("<entml:thinking>\n")
+    parser.feed("line one\n")
+    assert "line one" in parser.partial_thinking
+    assert not parser.has_calls
+    parser.feed(f"mention {INVOKE}\n")
+    assert INVOKE in parser.partial_thinking
+    assert not parser.has_calls
+    parser.feed("</entml:thinking>\nanswer")
+    clean, calls = parser.finalize()
+    assert not calls
+    assert "answer" in clean