echotools 2.3.52__tar.gz → 2.3.53__tar.gz

{echotools-2.3.52 → echotools-2.3.53}/PKG-INFO

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

{echotools-2.3.52 → echotools-2.3.53}/pyproject.toml

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

{echotools-2.3.52 → echotools-2.3.53}/src/echotools/exec/fncall/parsers/stream.py

@@ -349,6 +349,26 @@ class FncallStreamParser:
         body = self._fncall_buf[body_start:]
         self._json_stream_encoder._emitted = build_streaming_json_snapshot(body)
 
+    def _reclassify_orphan_thinking_close_in_text(self) -> None:
+        """将误进 visible 的「无开标签 + 闭标签」思考正文移回 thinking。"""
+        if self._thinking_filter is not None and self._thinking_filter.in_open_thinking():
+            return
+        from echotools.exec.fncall.protocols.entml_think.parse import (
+            _THINKING_CLOSE,
+            _THINKING_OPEN_PREFIX,
+        )
+
+        visible = "".join(self._text_parts)
+        if not visible or _THINKING_OPEN_PREFIX in visible:
+            return
+        close_at = visible.find(_THINKING_CLOSE)
+        if close_at < 0:
+            return
+        thinking_body = visible[:close_at]
+        after = visible[close_at + len(_THINKING_CLOSE) :].lstrip("\n")
+        self._thinking_parts.append(thinking_body)
+        self._text_parts = [after] if after else []
+
     def feed(self, chunk: str) -> List[Dict[str, Any]]:
         """喂入新的流式文本块。
 
@@ -370,6 +390,7 @@ class FncallStreamParser:
         ready = self.get_ready_tool_calls()
         if ready and self._json_stream_encoder is not None:
             self._sync_json_stream_encoder_emitted()
+        self._reclassify_orphan_thinking_close_in_text()
         return ready
 
     def _poll_streaming_tool_input_delta(self) -> Optional[Tuple[str, str]]:

{echotools-2.3.52 → echotools-2.3.53}/src/echotools/exec/fncall/protocols/entml.py

@@ -20,6 +20,7 @@ from echotools.exec.fncall.protocols.entml_invoke import (
 )
 from echotools.exec.fncall.protocols.entml_patterns import (
     BLOCK_RE,
+    entml_invoke_open_may_be_streaming,
     extract_attr_value,
     normalize_entml_name,
     strip_legacy_function_calls_wrapper,
@@ -225,7 +226,11 @@ class EntmlProtocol(ToolProtocol):
             if close < 0 and (hold is None or legacy_pos < hold):
                 hold = legacy_pos
         invoke_pos = buffer.find(self._TRIGGER_PREFIX)
-        if invoke_pos >= 0 and (hold is None or invoke_pos < hold):
+        if (
+            invoke_pos >= 0
+            and entml_invoke_open_may_be_streaming(buffer, invoke_pos)
+            and (hold is None or invoke_pos < hold)
+        ):
             hold = invoke_pos
         return hold
 

{echotools-2.3.52 → echotools-2.3.53}/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -60,6 +60,65 @@ _FENCE_ONLY_LINE_RE = re.compile(
     r"^\s*```(?:xml|entml|text)?\s*$",
     re.IGNORECASE | re.MULTILINE,
 )
+_INVOKE_OPEN_PREFIX = "<entml:invoke"
+_PLACEHOLDER_INVOKE_NAMES = frozenset({"$FUNCTION_NAME", "$FUNCTION_NAME2"})
+
+
+def is_placeholder_invoke_name(name: str) -> bool:
+    """提示词占位符（如 ``$FUNCTION_NAME``）不算真实工具调用。"""
+    n = (name or "").strip()
+    return not n or "$" in n
+
+
+def entml_invoke_open_is_actionable(buffer: str, pos: int) -> bool:
+    """``pos`` 处 ``<entml:invoke`` 是否为已闭合且含真实 name 的工具开标签。"""
+    if pos < 0 or not buffer.startswith(_INVOKE_OPEN_PREFIX, pos):
+        return False
+    gt = buffer.find(">", pos + len(_INVOKE_OPEN_PREFIX))
+    if gt < 0:
+        return False
+    attrs = buffer[pos + len(_INVOKE_OPEN_PREFIX) : gt]
+    name = extract_attr_value(attrs, "name")
+    if not name:
+        return False
+    name = normalize_entml_name(name)
+    return bool(name) and not is_placeholder_invoke_name(name)
+
+
+def entml_invoke_open_may_be_streaming(buffer: str, pos: int) -> bool:
+    """``pos`` 处 ``<entml:invoke`` 是否仍可能长成真实工具开标签（非 prose 提及）。"""
+    if pos < 0 or not buffer.startswith(_INVOKE_OPEN_PREFIX, pos):
+        return False
+    if entml_invoke_open_is_actionable(buffer, pos):
+        return True
+    gt = buffer.find(">", pos + len(_INVOKE_OPEN_PREFIX))
+    if gt < 0:
+        return True
+    return False
+
+
+def _strip_orphan_invoke_tags(content: str) -> str:
+    """仅剥离带真实 name 的 invoke 孤儿标签；保留 prose 中的 ``<entml:invoke>`` 提及。"""
+    pattern = re.compile(r"</?entml:invoke\b[^>]*/?>", re.DOTALL)
+
+    def repl(match: re.Match[str]) -> str:
+        tag = match.group(0)
+        if tag.startswith("</"):
+            return ""
+        if entml_invoke_open_is_actionable(content, match.start()):
+            return ""
+        return tag
+
+    return pattern.sub(repl, content)
+
+
+def _strip_orphan_non_invoke_tool_tags(content: str) -> str:
+    return re.sub(
+        r"</?entml:(?:function_calls|parameter|parameters)\b[^>]*/?>",
+        "",
+        content,
+        flags=re.DOTALL,
+    )
 
 
 def extract_attr_value(attrs: str, attr_name: str = "name") -> Optional[str]:
@@ -117,12 +176,13 @@ def strip_legacy_function_calls_wrapper(text: str) -> str:
 
 
 def strip_tool_entml_residue(content: str) -> str:
-    """剥离工具相关 entml 标签残留，保留 thinking 等非工具标签。"""
+    """剥离工具相关 entml 标签残留，保留 thinking 与非工具 prose 提及。"""
     if not content:
         return content
     cleaned = _TOOL_WRAPPER_PAIR_RE.sub("", content)
     cleaned = BLOCK_RE.sub("", cleaned)
-    cleaned = _TOOL_ORPHAN_TAG_RE.sub("", cleaned)
+    cleaned = _strip_orphan_invoke_tags(cleaned)
+    cleaned = _strip_orphan_non_invoke_tool_tags(cleaned)
     cleaned = _EMPTY_FENCE_RE.sub("", cleaned)
     cleaned = _FENCE_ONLY_LINE_RE.sub("", cleaned)
     # 折叠因剥离产生的多余空行

{echotools-2.3.52 → echotools-2.3.53}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -5,6 +5,7 @@ from typing import List, Optional, Tuple
 
 from echotools.exec.fncall.protocols.entml_patterns import (
     BLOCK_RE,
+    entml_invoke_open_may_be_streaming,
     extract_attr_value,
     normalize_entml_name,
 )
@@ -116,12 +117,22 @@ def find_ambiguous_entml_tool_prefix(buffer: str) -> int:
 
 
 def _hold_ambiguous_tool_markup(buffer: str) -> Tuple[str, str]:
-    """thinking 块内：从最早工具 entml 前缀处 hold，避免 invoke 被当作 thinking 吐出。"""
+    """thinking 块内：hold 可能长成真实工具调用的 markup（非 prose ``<entml:invoke>`` 提及）。"""
     if not buffer:
         return "", ""
-    ambig = find_ambiguous_entml_tool_prefix(buffer)
-    if ambig >= 0:
-        return buffer[:ambig], buffer[ambig:]
+    hold_from: Optional[int] = None
+    invoke_pos = buffer.find(_INVOKE_PREFIX)
+    if invoke_pos >= 0 and entml_invoke_open_may_be_streaming(buffer, invoke_pos):
+        if hold_from is None or invoke_pos < hold_from:
+            hold_from = invoke_pos
+    for prefix in _AMBIGUOUS_ENTML_PREFIXES:
+        if prefix == _INVOKE_PREFIX:
+            continue
+        pos = buffer.find(prefix)
+        if pos >= 0 and (hold_from is None or pos < hold_from):
+            hold_from = pos
+    if hold_from is not None:
+        return buffer[:hold_from], buffer[hold_from:]
     lt = buffer.rfind("<")
     if lt < 0:
         return buffer, ""
@@ -233,6 +244,22 @@ class EntmlThinkingStreamFilter:
         self._fault_buffer = ""
         self._thinking_started = False
 
+    def _resolve_orphan_thinking_close(self, out: List[Tuple[str, str]]) -> bool:
+        """仅有 ``</entml:thinking>`` 闭标签、无开标签时，将闭标签前 pending 视为 thinking。"""
+        close_at = self._pending.find(_THINKING_CLOSE)
+        if close_at < 0:
+            return False
+        if self._pending.find(_THINKING_OPEN_PREFIX) >= 0:
+            return False
+        before = self._pending[:close_at]
+        if before:
+            emitted = self._emit_thinking_piece(before)
+            if emitted:
+                out.append(("thinking", emitted))
+        self._pending = self._pending[close_at + len(_THINKING_CLOSE) :]
+        self._thinking_started = False
+        return True
+
     def in_open_thinking(self) -> bool:
         """思考块已开始且尚未收到 ``</entml:thinking>``（含开/闭标签分片 hold）。"""
         if self._in_block or self._fault_watch:
@@ -378,6 +405,9 @@ class EntmlThinkingStreamFilter:
 
     def _feed_before_block(self, out: List[Tuple[str, str]]) -> bool:
         """开标签之前或尚未进入块；返回 False 表示应退出 feed 主循环。"""
+        if self._resolve_orphan_thinking_close(out):
+            return True
+
         open_at = self._pending.find(_THINKING_OPEN_PREFIX)
         if open_at < 0:
             safe, self._pending = _hold_prefix(self._pending, _THINKING_OPEN_PREFIX)

{echotools-2.3.52 → echotools-2.3.53}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.52 → echotools-2.3.53}/src/tests/test_fncall_stream_thinking.py

@@ -170,6 +170,37 @@ def test_fault_thinking_close_without_invoke_is_plain_text() -> None:
     assert "answer" in clean
 
 
+def test_orphan_thinking_close_without_open_reclassified_from_visible() -> None:
+    """漏写 ``<entml:thinking>`` 仅有闭标签时，闭标签前正文应进 thinking 而非 visible。"""
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    text = "plan step one\nplan step two\n</entml:thinking>\nvisible reply\n"
+    for i in range(0, len(text), 9):
+        parser.feed(text[i : i + 9])
+    assert "plan step one" in parser.partial_thinking
+    assert "visible reply" in parser.partial_text
+    assert "</entml:thinking>" not in parser.partial_text
+
+
+def test_prose_invoke_mention_preserved_in_visible_text() -> None:
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    text = "当我使用`<entml:invoke>`格式时，参数要简单。\n"
+    parser.feed(text)
+    clean, calls = parser.finalize()
+    assert not calls
+    assert "<entml:invoke>" in parser.partial_text
+    assert "<entml:invoke>" in clean
+
+
+def test_prose_invoke_mention_preserved_in_thinking_stream() -> None:
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    text = "<entml:thinking>\n当我使用`<entml:invoke>`格式时\n</entml:thinking>\n"
+    for i in range(0, len(text), 4):
+        parser.feed(text[i : i + 4])
+    _, calls = parser.finalize()
+    assert not calls
+    assert "<entml:invoke>" in parser.partial_thinking
+
+
 def test_stream_delta_not_duplicated_after_invoke_in_thinking() -> None:
     """thinking 内 invoke ready 后，下一 chunk 不应重发整段 partial_json。"""
     import json