echotools 2.3.78__tar.gz → 2.3.80__tar.gz

{echotools-2.3.78 → echotools-2.3.80}/PKG-INFO

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

{echotools-2.3.78 → echotools-2.3.80}/pyproject.toml

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

{echotools-2.3.78 → echotools-2.3.80}/src/echotools/exec/fncall/parsers/stream.py

@@ -615,23 +615,14 @@ class FncallStreamParser:
 
     def _stream_visible_buffer(self) -> str:
         """与 batch ``parse`` 一致：未闭合 thinking 之后的正文不参与可见/剥离。"""
-        buf = self._raw_buf
-        if not buf:
-            return ""
         from echotools.exec.fncall.protocols.entml_think.parse import (
-            _find_earliest_thinking_open,
-            has_unclosed_entml_thinking,
+            stream_safe_visible_prefix,
         )
 
-        if has_unclosed_entml_thinking(
-            buf, thinking_enabled=self._thinking_enabled
-        ):
-            open_at, _ = _find_earliest_thinking_open(
-                buf, thinking_enabled=self._thinking_enabled
-            )
-            if open_at >= 0:
-                return buf[:open_at]
-        return buf
+        return stream_safe_visible_prefix(
+            self._raw_buf,
+            thinking_enabled=self._thinking_enabled,
+        )
 
     def _stream_display_text(self) -> str:
         """流式可见正文：在完整 raw 缓冲上剥离伪 history（保留 thinking 保护区）。"""
@@ -671,7 +662,11 @@ class FncallStreamParser:
                     self._text_parts.append(part)
 
         # 与 batch parse 同路径（须在含 thinking 标签的 raw 缓冲上剥离伪 history）。
-        clean_text, tool_calls = self._protocol.parse(self._raw_buf, self._tools)
+        clean_text, tool_calls = self._protocol.parse(
+            self._raw_buf,
+            self._tools,
+            thinking_enabled=self._thinking_enabled,
+        )
 
         clean_fn = getattr(self._protocol, "clean_tool_tags", None)
         if callable(clean_fn):
@@ -728,7 +723,14 @@ class FncallStreamParser:
         if self._thinking_enabled and self._raw_buf:
             lower = self._raw_buf.lower()
             if "<entml:invoke" not in lower and "<entml:function_calls" not in lower:
-                return self._stream_display_text()
+                display = self._stream_display_text()
+                if display:
+                    from echotools.exec.fncall.shared.history_markup import (
+                        strip_fake_history_markup_for_display,
+                    )
+
+                    cleaned, _ = strip_fake_history_markup_for_display(display)
+                    return cleaned
         return ""
 
     @property
@@ -748,6 +750,7 @@ class FncallStreamParser:
                 parse_kwargs: Dict[str, Any] = {}
                 if getattr(self._protocol, "id", None) == "entml":
                     parse_kwargs["include_tool_blocks"] = False
+                    parse_kwargs["thinking_enabled"] = self._thinking_enabled
                 _, all_calls = self._protocol.parse(
                     self._raw_buf, self._tools, **parse_kwargs
                 )

{echotools-2.3.78 → echotools-2.3.80}/src/echotools/exec/fncall/protocols/entml.py

@@ -18,7 +18,10 @@ from echotools.exec.fncall.prompt.templates import (
 from echotools.exec.fncall.protocols.entml_invoke import (
     parse_entml_tool_calls,
 )
-from echotools.exec.fncall.protocols.entml_tool_blocks import parse_tool_block_calls
+from echotools.exec.fncall.protocols.entml_tool_blocks import (
+    parse_tool_block_calls,
+    strip_tool_block_spans,
+)
 from echotools.exec.fncall.protocols.entml_patterns import (
     BLOCK_RE,
     entml_invoke_open_may_be_streaming,
@@ -151,12 +154,13 @@ class EntmlProtocol(ToolProtocol):
     _THINKING_PREFIX = "<entml:thinking"
 
     def get_trigger_tags(self) -> List[str]:
-        # invoke / thinking 前缀 holdback，避免 `<e` 歧义被提前吐出
+        # invoke / thinking / 伪 history tool 前缀 holdback，避免 `<e` / `<t` 歧义被提前吐出
         return [
             self._TRIGGER,
             self._TRIGGER_PREFIX,
             self._THINKING_PREFIX,
             f"{self._THINKING_PREFIX}>",
+            "<tool",
         ]
 
     def normalize_stream_buffer(self, buffer: str) -> str:
@@ -271,6 +275,7 @@ class EntmlProtocol(ToolProtocol):
         tools: Optional[List[Dict[str, Any]]] = None,
         *,
         include_tool_blocks: bool = True,
+        thinking_enabled: bool = True,
     ) -> Tuple[str, List[Dict[str, Any]]]:
         from echotools.exec.fncall.protocols.entml_think.parse import (
             _find_earliest_thinking_open,
@@ -279,6 +284,7 @@ class EntmlProtocol(ToolProtocol):
         )
 
         schema_index = _build_param_schema_index(tools) if tools else None
+        # 工具解析始终按 thinking 开启语义分流（fault ``</thinking>`` 等）；可见正文再按 thinking_enabled 剥离。
         parse_text, _thinking = split_entml_thinking(text, thinking_enabled=True)
         unclosed_open_at = -1
         if has_unclosed_entml_thinking(text, thinking_enabled=True):
@@ -288,10 +294,18 @@ class EntmlProtocol(ToolProtocol):
             if unclosed_open_at >= 0:
                 parse_text = text[:unclosed_open_at]
         tool_calls = parse_entml_tool_calls(parse_text, tools, schema_index)
+        tool_block_calls: List[Dict[str, Any]] = []
         if include_tool_blocks:
-            tool_calls.extend(parse_tool_block_calls(parse_text, tools, schema_index))
+            tool_block_calls = parse_tool_block_calls(parse_text, tools, schema_index)
+            tool_calls.extend(tool_block_calls)
         clean = text[:unclosed_open_at] if unclosed_open_at >= 0 else text
-        # 须在移除 invoke 之前剥离伪 history，否则未闭合 <tool> 会把 invoke 之后的可见回复误删。
+        if thinking_enabled:
+            # fault ``</thinking>`` 须借后续 invoke 判定闭合；thinking 剥离必须在 invoke 移除之前。
+            visible, _ = split_entml_thinking(clean, thinking_enabled=True)
+            clean = visible
+        if tool_block_calls:
+            clean = strip_tool_block_spans(clean)
+        # 须在移除 invoke 之前剥离伪 history，且须晚于已解析的 ``<tool>`` 块剥离。
         clean, _ = strip_fake_history_markup(clean)
         if tool_calls:
             clean = BLOCK_RE.sub("", clean)

{echotools-2.3.78 → echotools-2.3.80}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -26,6 +26,56 @@ _AMBIGUOUS_ENTML_PREFIXES = (
     "<entml:parameters",
 )
 _INVOKE_PREFIX = "<entml:invoke"
+_FUNCTION_CALLS_PREFIX = "<entml:function_calls"
+_LEADING_HOLD_PREFIXES = _AMBIGUOUS_ENTML_PREFIXES + (
+    _THINKING_OPEN_PREFIX,
+    _FUNCTION_CALLS_PREFIX,
+    "<tool",
+    "<assistant",
+)
+
+
+def leading_entml_tag_holdback_len(
+    text: str,
+    *,
+    thinking_enabled: bool = True,
+) -> int:
+    """buffer 开头是 entml/thinking/invoke 标签真前缀时，应 hold 的字节数。"""
+    if not text:
+        return 0
+    prefixes: List[str] = list(_LEADING_HOLD_PREFIXES)
+    if thinking_enabled:
+        prefixes.append(_PLAIN_THINKING_OPEN_PREFIX)
+    for prefix in prefixes:
+        if text.startswith(prefix):
+            return 0
+    max_hold = max(len(prefix) - 1 for prefix in prefixes)
+    for length in range(min(len(text), max_hold), 0, -1):
+        head = text[:length]
+        if any(prefix.startswith(head) and head != prefix for prefix in prefixes):
+            return length
+    return 0
+
+
+def stream_safe_visible_prefix(
+    text: str,
+    *,
+    thinking_enabled: bool = True,
+) -> str:
+    """流式 UI 可安全展示的 prefix（不含未收齐的 entml/thinking 开标签）。"""
+    if not text:
+        return ""
+    hold = leading_entml_tag_holdback_len(text, thinking_enabled=thinking_enabled)
+    if hold >= len(text):
+        return ""
+    buf = text[hold:]
+    if has_unclosed_entml_thinking(buf, thinking_enabled=thinking_enabled):
+        open_at, _ = _find_earliest_thinking_open(
+            buf, thinking_enabled=thinking_enabled
+        )
+        if open_at >= 0:
+            return buf[:open_at]
+    return buf
 
 
 def find_complete_entml_invoke_open(buffer: str) -> int:

{echotools-2.3.78 → echotools-2.3.80}/src/echotools/exec/fncall/protocols/entml_tool_blocks.py

@@ -4,11 +4,17 @@ from __future__ import annotations
 
 import json
 import re
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple
 
 from .entml_patterns import INVOKE_RE, normalize_entml_name
 from .entml_values import coerce_entml_arguments
 
+_TOOL_BLOCK_OPEN_RE = re.compile(r"<tool\s*>", re.IGNORECASE)
+_TOOL_BLOCK_CLOSE_RE = re.compile(
+    r"(?:</tool\s*>|</system\b[^>]*>|</assistant\s*>)",
+    re.IGNORECASE,
+)
+# legacy 整段匹配（测试/简单场景）
 _TOOL_BLOCK_RE = re.compile(
     r"<tool\s*>\s*([\s\S]*?)\s*</tool\s*>",
     re.IGNORECASE,
@@ -18,8 +24,9 @@ _INNER_TOOL_TAG_RE = re.compile(
     re.IGNORECASE,
 )
 _BRACE_TOOL_HEAD_RE = re.compile(r"\{([A-Za-z][A-Za-z0-9_]*)\s*:\s*")
-# 工具结果常见行号泄漏（Read 伪块）
+# 工具结果常见行号泄漏（Read 伪块）— 仅用于多块 brace 判定
 _OUTPUT_LINE_RE = re.compile(r"^\s*\d+\s+\S", re.MULTILINE)
+_SCALAR_ARG_KEYS = ("path", "command", "pattern", "query", "file_path")
 
 
 def _known_tool_names(
@@ -53,25 +60,116 @@ def _args_from_parsed(name: str, parsed: Any) -> Dict[str, Any]:
     return {"value": parsed}
 
 
+def _args_from_scalar(
+    name: str,
+    scalar: str,
+    schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]],
+) -> Dict[str, Any]:
+    """``{Read: path/to/file}`` / ``{Bash: echo hi}`` 等标量行。"""
+    func_props = (schema_index or {}).get(name) or {}
+    if len(func_props) == 1:
+        key = next(iter(func_props))
+        return {key: scalar}
+    for key in _SCALAR_ARG_KEYS:
+        if key in func_props:
+            return {key: scalar}
+    return {"value": scalar}
+
+
+def _looks_like_file_path(value: str) -> bool:
+    text = (value or "").strip()
+    if not text:
+        return False
+    if "/" in text or "\\" in text:
+        return True
+    if len(text) >= 2 and text[1] == ":" and text[0].isalpha():
+        return True
+    return False
+
+
 def _extract_first_brace_tool_call(body: str) -> Optional[Tuple[str, Any]]:
-    """从正文提取首个 ``{Tool: json}``（允许后面跟工具输出 tail）。"""
+    """从正文提取首个 ``{Tool: json|scalar}``（允许后面跟工具输出 tail）。"""
     match = _BRACE_TOOL_HEAD_RE.search(body)
     if not match:
         return None
     name = normalize_entml_name(match.group(1))
     rest = body[match.end() :].lstrip()
-    if not rest or rest[0] not in "{[":
+    if not rest:
         return None
-    try:
-        parsed, end = json.JSONDecoder().raw_decode(rest)
-    except json.JSONDecodeError:
+    if rest[0] in "{[":
+        try:
+            parsed, end = json.JSONDecoder().raw_decode(rest)
+        except json.JSONDecodeError:
+            return None
+        after = rest[end:].lstrip()
+        if after.startswith("}"):
+            after = after[1:].lstrip()
+        # JSON + 行号 tail 为 history Read 伪块；标量 path + tail 仍解析（模型误格式真调用）
+        if after and _OUTPUT_LINE_RE.search(after):
+            return None
+        return name, parsed
+    close = rest.find("}")
+    if close < 0:
+        return None
+    scalar = rest[:close].strip()
+    if not scalar:
         return None
-    after = rest[end:].lstrip()
-    if after.startswith("}"):
-        after = after[1:].lstrip()
-    if after and _OUTPUT_LINE_RE.search(after):
+    after = rest[close + 1 :]
+    has_output_tail = bool(_OUTPUT_LINE_RE.search(after))
+    # 标量行：仅 path 型 Read/Glob 或带 Read 行号 tail；``{Bash: echo hi}`` 视为 history
+    if not has_output_tail and not _looks_like_file_path(scalar):
         return None
-    return name, parsed
+    return name, scalar
+
+
+def _iter_tool_block_spans(text: str) -> Iterator[Tuple[int, int, str]]:
+    """yield ``(open_start, close_end, body)``。"""
+    if not text or "<tool" not in text.lower():
+        return
+    pos = 0
+    while True:
+        open_m = _TOOL_BLOCK_OPEN_RE.search(text, pos)
+        if not open_m:
+            break
+        body_start = open_m.end()
+        close_m = _TOOL_BLOCK_CLOSE_RE.search(text, body_start)
+        if close_m:
+            close_end = close_m.end()
+            close_tag = text[close_m.start() : close_m.end()].lower()
+            if close_tag.startswith("</system"):
+                after = text[close_end:]
+                footer = re.match(
+                    r"[^\n<]*(?:</system\s*>)?",
+                    after,
+                    re.IGNORECASE,
+                )
+                if footer:
+                    close_end += footer.end()
+                after = text[close_end:]
+                asst = re.search(r"^\s*</assistant\s*>", after, re.IGNORECASE | re.MULTILINE)
+                if asst:
+                    close_end += asst.end()
+            yield open_m.start(), close_end, text[body_start : close_m.start()]
+            pos = close_end
+        else:
+            yield open_m.start(), len(text), text[body_start:]
+            break
+
+
+def strip_tool_block_spans(text: str) -> str:
+    """移除 ``<tool>…`` 块（含误用的 ``</system>`` / ``</assistant>`` 闭合）。"""
+    if not text or "<tool" not in text.lower():
+        return text
+    parts: List[str] = []
+    last = 0
+    for open_start, close_end, _body in _iter_tool_block_spans(text):
+        parts.append(text[last:open_start])
+        last = close_end
+    parts.append(text[last:])
+    out = "".join(parts)
+    out = re.sub(r"^\s*<assistant\s*>\s*\n+", "", out, count=1, flags=re.IGNORECASE)
+    out = re.sub(r"\n{3,}", "\n\n", out)
+    return out.strip()
 
 
 def _parse_inner_tag_calls(
@@ -114,7 +212,11 @@ def _parse_brace_calls(
     name, value = parsed
     if known and name not in known:
         return []
-    args = coerce_entml_arguments(_args_from_parsed(name, value), name, schema_index)
+    if isinstance(value, str):
+        args = _args_from_scalar(name, value, schema_index)
+    else:
+        args = _args_from_parsed(name, value)
+    args = coerce_entml_arguments(args, name, schema_index)
     return [(name, args)]
 
 
@@ -152,9 +254,9 @@ def parse_tool_block_calls(
 
     allow_brace = not bool(INVOKE_RE.search(text))
     tool_calls: List[Dict[str, Any]] = []
-    for match in _TOOL_BLOCK_RE.finditer(text):
+    for _open, _close, body in _iter_tool_block_spans(text):
         for name, args in parse_tool_block_body(
-            match.group(1),
+            body,
             tools=tools,
             schema_index=schema_index,
             allow_brace_format=allow_brace,

{echotools-2.3.78 → echotools-2.3.80}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.78 → echotools-2.3.80}/src/echotools.egg-info/SOURCES.txt

@@ -186,6 +186,7 @@ src/tests/test_dispatch_extended.py
 src/tests/test_dispatch_race.py
 src/tests/test_entml_agent_output_formats.py
 src/tests/test_entml_bare_invoke_format.py
+src/tests/test_entml_batch_stream_comprehensive.py
 src/tests/test_entml_parser_comprehensive.py
 src/tests/test_entml_protocol.py
 src/tests/test_entml_stream_json.py