echotools 2.3.38__tar.gz → 2.3.40__tar.gz

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "echotools"
-version = "2.3.38"
+version = "2.3.40"
 description = "通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链"
 readme = "docs/README.md"
 requires-python = ">=3.8"
@@ -97,6 +97,10 @@ disable_error_code = [
 module = "echotools.exec.terminal.*"
 ignore_errors = true
 
+[[tool.mypy.overrides]]
+module = "echotools.media.console.ui"
+ignore_errors = true
+
 [tool.pytest.ini_options]
 testpaths = ["src/tests"]
 asyncio_mode = "auto"

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

@@ -9,10 +9,13 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from echotools.exec.protocol.base import ToolProtocol
 
+
 # 懒导入：仅 entml 协议需要
 def _make_thinking_filter(protocol: ToolProtocol):
     if getattr(protocol, "id", None) == "entml":
-        from echotools.exec.fncall.protocols.entml_thinking_parse import EntmlThinkingStreamFilter
+        from echotools.exec.fncall.protocols.entml_thinking_parse import (
+            EntmlThinkingStreamFilter,
+        )
         return EntmlThinkingStreamFilter()
     return None
 
@@ -133,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)
@@ -151,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
 
@@ -213,7 +262,9 @@ class FncallStreamParser:
 
         # 兜底：剥离残留 <entml:thinking>（holdback 边界/分片异常时）
         if self._thinking_filter is not None and clean_text:
-            from echotools.exec.fncall.protocols.entml_thinking_parse import split_entml_thinking
+            from echotools.exec.fncall.protocols.entml_thinking_parse import (
+                split_entml_thinking,
+            )
             clean_text, more_thinking = split_entml_thinking(clean_text)
             if more_thinking:
                 self._thinking_parts.append(more_thinking)

{echotools-2.3.38 → echotools-2.3.40}/src/echotools/exec/fncall/prompt/inject.py

@@ -28,7 +28,10 @@ from echotools.exec.fncall.protocols.entml_thinking_history import (
     parse_include_thinking_in_history,
 )
 from echotools.exec.fncall.shared.loop_detect import detect_tool_loop
-from echotools.exec.fncall.shared.normalization import format_tool_descs, normalize_content
+from echotools.exec.fncall.shared.normalization import (
+    format_tool_descs,
+    normalize_content,
+)
 from echotools.exec.protocol.base import ToolProtocol
 
 __all__ = ["inject_fncall"]

{echotools-2.3.38 → echotools-2.3.40}/src/echotools/exec/fncall/prompt/prompt_helpers.py

@@ -3,6 +3,10 @@ from __future__ import annotations
 from typing import Any, Dict, List, Optional, Set, Tuple
 
 from echotools.base.logger.manager import get_logger
+from echotools.exec.fncall.protocols.entml_thinking_history import (
+    extract_reasoning_text,
+    format_entml_thinking_history_block,
+)
 from echotools.exec.fncall.shared.normalization import normalize_content
 
 from .history import (
@@ -15,11 +19,6 @@ from .history import (
     _try_convert_user_to_tool,
 )
 
-from echotools.exec.fncall.protocols.entml_thinking_history import (
-    extract_reasoning_text,
-    format_entml_thinking_history_block,
-)
-
 logger = get_logger(__name__)
 
 
@@ -86,7 +85,8 @@ def _format_assistant_text_block(
     )
     if not blocks:
         return None
-    return f"<assistant>\n{'\n\n'.join(blocks)}\n</assistant>"
+    body = "\n\n".join(blocks)
+    return f"<assistant>\n{body}\n</assistant>"
 
 
 def _register_tool_call_names(

{echotools-2.3.38 → echotools-2.3.40}/src/echotools/exec/fncall/protocols/entml.py

@@ -15,7 +15,6 @@ from echotools.exec.fncall.prompt.templates import (
     _HISTORY_TOOL_INVOKE_REMINDER_EN,
 )
 from echotools.exec.fncall.protocols.entml_invoke import (
-    format_entml_tool_calls,
     parse_entml_tool_calls,
 )
 from echotools.exec.fncall.protocols.entml_patterns import BLOCK_RE

{echotools-2.3.38 → echotools-2.3.40}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -4,7 +4,6 @@ import json
 from typing import Any, Dict, List, Optional
 
 from .entml_patterns import (
-    BLOCK_RE,
     INVOKE_RE,
     PARAM_RE,
     PARAMETERS_RE,

{echotools-2.3.38 → 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.38 → echotools-2.3.40}/src/echotools/media/console/spinner.py

@@ -6,13 +6,13 @@ Spinner 动画引擎 - 绿→蓝单向渐变版
 - stop() 后恢复光标并清除 spinner 行
 """
 
-import sys
-import time
+import math
 import os
 import platform
-import math
+import sys
 import threading
-from typing import List, Tuple, Dict, Callable, Optional
+import time
+from typing import Callable, Dict, List, Optional, Tuple
 
 try:
     from wcwidth import wcswidth as _wcswidth

{echotools-2.3.38 → echotools-2.3.40}/src/echotools/media/console/ui.py

@@ -22,12 +22,11 @@ import math
 import os
 import re
 import sys
-from pathlib import Path
 import threading
 import time
-from contextlib import contextmanager
 from dataclasses import dataclass, field
 from enum import Enum, auto
+from pathlib import Path
 from typing import (
     Any,
     AsyncIterator,
@@ -51,7 +50,7 @@ from typing import (
 
 from rich.console import Console
 from rich.text import Text
-from wcwidth import wcwidth, wcswidth
+from wcwidth import wcswidth, wcwidth
 
 # ══════════════════════════════════════════════════════════════════════════════
 # 类型定义与平台常量
@@ -133,39 +132,39 @@ class _WindowsBackend:
 
     def _define_structures(self) -> None:
         """定义 Windows 控制台输入记录结构体"""
-        ctypes = self._ctypes
+        ct = self._ctypes
 
-        class COORD(ctypes.Structure):
-            _fields_ = [("X", ctypes.c_short), ("Y", ctypes.c_short)]
+        class COORD(ct.Structure):
+            _fields_ = [("X", ct.c_short), ("Y", ct.c_short)]
 
-        class KEY_EVENT_RECORD(ctypes.Structure):
+        class KEY_EVENT_RECORD(ct.Structure):
             _fields_ = [
-                ("bKeyDown", ctypes.wintypes.BOOL),
-                ("wRepeatCount", ctypes.wintypes.WORD),
-                ("wVirtualKeyCode", ctypes.wintypes.WORD),
-                ("wVirtualScanCode", ctypes.wintypes.WORD),
-                ("uChar", ctypes.wintypes.WCHAR),
-                ("dwControlKeyState", ctypes.wintypes.DWORD),
+                ("bKeyDown", ct.wintypes.BOOL),
+                ("wRepeatCount", ct.wintypes.WORD),
+                ("wVirtualKeyCode", ct.wintypes.WORD),
+                ("wVirtualScanCode", ct.wintypes.WORD),
+                ("uChar", ct.wintypes.WCHAR),
+                ("dwControlKeyState", ct.wintypes.DWORD),
             ]
 
-        class MOUSE_EVENT_RECORD(ctypes.Structure):
+        class MOUSE_EVENT_RECORD(ct.Structure):
             _fields_ = [
                 ("dwMousePosition", COORD),
-                ("dwButtonState", ctypes.wintypes.DWORD),
-                ("dwControlKeyState", ctypes.wintypes.DWORD),
-                ("dwEventFlags", ctypes.wintypes.DWORD),
+                ("dwButtonState", ct.wintypes.DWORD),
+                ("dwControlKeyState", ct.wintypes.DWORD),
+                ("dwEventFlags", ct.wintypes.DWORD),
             ]
 
-        class WINDOW_BUFFER_SIZE_RECORD(ctypes.Structure):
+        class WINDOW_BUFFER_SIZE_RECORD(ct.Structure):
             _fields_ = [("dwSize", COORD)]
 
-        class MENU_EVENT_RECORD(ctypes.Structure):
-            _fields_ = [("dwCommandId", ctypes.wintypes.UINT)]
+        class MENU_EVENT_RECORD(ct.Structure):
+            _fields_ = [("dwCommandId", ct.wintypes.UINT)]
 
-        class FOCUS_EVENT_RECORD(ctypes.Structure):
-            _fields_ = [("bSetFocus", ctypes.wintypes.BOOL)]
+        class FOCUS_EVENT_RECORD(ct.Structure):
+            _fields_ = [("bSetFocus", ct.wintypes.BOOL)]
 
-        class INPUT_RECORD_EVENT(ctypes.Union):
+        class INPUT_RECORD_EVENT(ct.Union):
             _fields_ = [
                 ("KeyEvent", KEY_EVENT_RECORD),
                 ("MouseEvent", MOUSE_EVENT_RECORD),
@@ -174,9 +173,9 @@ class _WindowsBackend:
                 ("FocusEvent", FOCUS_EVENT_RECORD),
             ]
 
-        class INPUT_RECORD(ctypes.Structure):
+        class INPUT_RECORD(ct.Structure):
             _fields_ = [
-                ("EventType", ctypes.wintypes.WORD),
+                ("EventType", ct.wintypes.WORD),
                 ("Event", INPUT_RECORD_EVENT),
             ]
 
@@ -304,8 +303,8 @@ class _UnixBackend:
                         vk = arrow_map.get(ch3, "unknown")
                         # 消费 Delete 键的尾部 '~'
                         if ch3 == "3":
-                            extra, _, _ = select.select([fd], [], [], 0.02)
-                            if extra:
+                            pending_del, _, _ = select.select([fd], [], [], 0.02)
+                            if pending_del:
                                 os.read(fd, 1)
                         results.append({
                             "type": "key", "vk": vk,
@@ -389,10 +388,10 @@ class _UnixBackend:
                     # 尝试读取更多字节以组成完整 UTF-8 字符
                     more, _, _ = select.select([fd], [], [], 0.02)
                     if more:
-                        extra = os.read(fd, 3).decode(
+                        utf_tail = os.read(fd, 3).decode(
                             "utf-8", errors="replace",
                         )
-                        full_char += extra
+                        full_char += utf_tail
                 results.append({
                     "type": "key", "vk": "char",
                     "char": full_char, "ctrl": False,

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

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

{echotools-2.3.38 → 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.38 → echotools-2.3.40}/src/tests/test_console.py

@@ -8,8 +8,6 @@ def test_console_package_import() -> None:
         BorderStyle,
         Clock,
         ConsoleUI,
-        FontStyle,
-        GradientTheme,
         Spinner,
         char_map,
     )

{echotools-2.3.38 → 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