echotools 2.3.88__tar.gz → 2.3.89__tar.gz

{echotools-2.3.88 → echotools-2.3.89}/PKG-INFO

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

{echotools-2.3.88 → echotools-2.3.89}/pyproject.toml

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

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/parsers/stream.py

@@ -100,6 +100,11 @@ class FncallStreamParser(StreamFeedMixin, StreamDeltaMixin, StreamFinalMixin):
             self._schema_index = _build_param_schema_index(self._tools)
         return self._schema_index
 
+    def _get_known_tool_names(self):
+        from echotools.exec.fncall.protocols.entml_patterns import resolve_known_tool_names
+
+        return resolve_known_tool_names(self._tools, self._get_schema_index())
+
     def _emit_text(self, text: str) -> None:
         """将文本路由给思考过滤器（若启用）或直接追加到 _text_parts。"""
         if not text:

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/parsers/stream_delta.py

@@ -26,7 +26,7 @@ class StreamDeltaMixin:
 
         complete = list(INVOKE_RE.finditer(self._fncall_buf))
         complete_n = len(complete)
-        parsed = split_invoke_open(self._fncall_buf)
+        parsed = split_invoke_open(self._fncall_buf, known_names=self._get_known_tool_names())
         if parsed is None:
             return max(0, complete_n - 1)
         _name, body_start = parsed
@@ -77,7 +77,7 @@ class StreamDeltaMixin:
             build_streaming_json_snapshot,
             split_invoke_open,
         )
-        parsed = split_invoke_open(self._fncall_buf)
+        parsed = split_invoke_open(self._fncall_buf, known_names=self._get_known_tool_names())
         if not parsed:
             self._json_stream_encoder.reset()
             return
@@ -125,7 +125,7 @@ class StreamDeltaMixin:
             split_invoke_open,
         )
 
-        parsed = split_invoke_open(self._fncall_buf)
+        parsed = split_invoke_open(self._fncall_buf, known_names=self._get_known_tool_names())
         if not parsed:
             self._json_stream_encoder.reset()
             return
@@ -172,7 +172,7 @@ class StreamDeltaMixin:
             split_invoke_open,
         )
 
-        parsed = split_invoke_open(self._fncall_buf)
+        parsed = split_invoke_open(self._fncall_buf, known_names=self._get_known_tool_names())
         if not parsed:
             return None
         name, body_start = parsed
@@ -241,7 +241,7 @@ class StreamDeltaMixin:
             split_invoke_open,
         )
 
-        parsed = split_invoke_open(self._fncall_buf)
+        parsed = split_invoke_open(self._fncall_buf, known_names=self._get_known_tool_names())
         if not parsed:
             return None
         name, body_start = parsed

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/parsers/stream_feed.py

@@ -37,7 +37,7 @@ class StreamFeedMixin:
         """True 表示已消费 text（含 holdback）。"""
         hold_from_fn = getattr(self._protocol, "find_fncall_hold_from", None)
         if hold_from_fn is not None:
-            hold_from = hold_from_fn(text)
+            hold_from = hold_from_fn(text, tools=self._tools)
             if hold_from is not None:
                 if hold_from > 0:
                     self._append_content_text(text[:hold_from])
@@ -52,7 +52,7 @@ class StreamFeedMixin:
     def _hold_or_split_emit(self, text: str, trigger_tags) -> None:
         hold_from_fn = getattr(self._protocol, "find_fncall_hold_from", None)
         if hold_from_fn is not None:
-            hold_from = hold_from_fn(text)
+            hold_from = hold_from_fn(text, tools=self._tools)
             if hold_from is not None:
                 if hold_from > 0:
                     self._emit_text(text[:hold_from])
@@ -81,7 +81,7 @@ class StreamFeedMixin:
                 self._fncall_buf += text
                 return
             trigger_tags = self._protocol.get_trigger_tags()
-            found, pos = self._protocol.detect_start(text)
+            found, pos = self._protocol.detect_start(text, tools=self._tools)
             if found:
                 if pos > 0:
                     self._append_content_text(text[:pos])
@@ -90,7 +90,7 @@ class StreamFeedMixin:
             self._hold_or_split_content(text, trigger_tags)
             return
         trigger_tags = self._protocol.get_trigger_tags()
-        found, pos = self._protocol.detect_start(text)
+        found, pos = self._protocol.detect_start(text, tools=self._tools)
         if not found:
             self._hold_or_split_content(text, trigger_tags)
             return
@@ -138,7 +138,7 @@ class StreamFeedMixin:
             self._feed_waiting_thinking_plain(combined)
             return
         trigger_tags = self._protocol.get_trigger_tags()
-        found, pos = self._protocol.detect_start(combined)
+        found, pos = self._protocol.detect_start(combined, tools=self._tools)
         if found:
             if self._thinking_filter is not None:
                 from echotools.exec.fncall.protocols.entml_think.parse import (

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/parsers/stream_final.py

@@ -67,10 +67,18 @@ class StreamFinalMixin:
 
         lower = raw.lower()
         cut = len(raw)
-        for marker in ("<entml:invoke", "<entml:function_calls"):
-            pos = lower.find(marker)
-            if pos >= 0:
-                cut = min(cut, pos)
+        from echotools.exec.fncall.protocols.entml_patterns import (
+            find_actionable_entml_invoke_open,
+        )
+
+        invoke_pos = find_actionable_entml_invoke_open(
+            raw, known_names=self._get_known_tool_names()
+        )
+        if invoke_pos >= 0:
+            cut = min(cut, invoke_pos)
+        legacy_pos = lower.find("<entml:function_calls")
+        if legacy_pos >= 0:
+            cut = min(cut, legacy_pos)
         segment = raw[:cut]
 
         buf = stream_safe_visible_prefix(
@@ -128,12 +136,25 @@ class StreamFinalMixin:
         )
         clean_fn = getattr(self._protocol, "clean_tool_tags", None)
         if callable(clean_fn):
-            clean_text = clean_fn(clean_text)
+            import inspect
+
+            sig = inspect.signature(clean_fn)
+            if "tools" in sig.parameters:
+                clean_text = clean_fn(clean_text, tools=self._tools)
+            else:
+                clean_text = clean_fn(clean_text)
         elif getattr(self._protocol, "id", None) == "entml":
             from echotools.exec.fncall.protocols.entml_patterns import (
+                resolve_known_tool_names,
                 strip_tool_entml_residue,
             )
-            clean_text = strip_tool_entml_residue(clean_text)
+
+            clean_text = strip_tool_entml_residue(
+                clean_text,
+                known_names=resolve_known_tool_names(
+                    self._tools, self._get_schema_index()
+                ),
+            )
         display_text = self._finalize_display_text(clean_text)
         self._text_parts = [display_text] if display_text else []
         self._finalized_result = (display_text, tool_calls)

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/protocols/entml.py

@@ -25,7 +25,9 @@ from echotools.exec.fncall.protocols.entml_think.blocks import (
 from echotools.exec.fncall.protocols.entml_patterns import (
     entml_invoke_open_may_be_streaming,
     extract_attr_value,
+    find_actionable_entml_invoke_open,
     normalize_entml_name,
+    resolve_known_tool_names,
     strip_actionable_entml_invoke_blocks,
     strip_legacy_function_calls_wrapper,
     strip_tool_entml_residue,
@@ -215,16 +217,28 @@ class EntmlProtocol(ToolProtocol):
 
         return "\n\n".join(sections)
 
-    def detect_start(self, buffer: str) -> Tuple[bool, int]:
-        """invoke 开标签（含 name 且闭合 ``>``）稳定后才视为工具流开始。"""
-        invoke_pos = self._find_complete_invoke_open(buffer)
+    def detect_start(
+        self,
+        buffer: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Tuple[bool, int]:
+        """invoke 开标签（闭合 ``>`` 且 name 在 tools 内）稳定后才视为工具流开始。"""
+        schema_index = _build_param_schema_index(tools) if tools else None
+        known = resolve_known_tool_names(tools, schema_index)
+        invoke_pos = find_actionable_entml_invoke_open(buffer, known_names=known)
         if invoke_pos < 0:
             return (False, -1)
         return (True, invoke_pos)
 
-    def find_fncall_hold_from(self, buffer: str) -> Optional[int]:
+    def find_fncall_hold_from(
+        self,
+        buffer: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Optional[int]:
         """invoke 未稳定前 hold 前缀；legacy 外壳开标签未闭合时同样 hold。"""
-        if self._find_complete_invoke_open(buffer) >= 0:
+        schema_index = _build_param_schema_index(tools) if tools else None
+        known = resolve_known_tool_names(tools, schema_index)
+        if find_actionable_entml_invoke_open(buffer, known_names=known) >= 0:
             return None
         hold: Optional[int] = None
         legacy_pos = buffer.find(self._LEGACY_WRAPPER_PREFIX)
@@ -235,28 +249,23 @@ class EntmlProtocol(ToolProtocol):
         invoke_pos = buffer.find(self._TRIGGER_PREFIX)
         if (
             invoke_pos >= 0
-            and entml_invoke_open_may_be_streaming(buffer, invoke_pos)
+            and entml_invoke_open_may_be_streaming(
+                buffer, invoke_pos, known_names=known
+            )
             and (hold is None or invoke_pos < hold)
         ):
             hold = invoke_pos
         return hold
 
-    def _find_complete_invoke_open(self, buffer: str) -> int:
-        """返回首个含 name 且已闭合 ``>`` 的 ``<entml:invoke`` 起始下标；否则 -1。"""
-        search_from = 0
-        prefix_len = len(self._TRIGGER_PREFIX)
-        while True:
-            pos = buffer.find(self._TRIGGER_PREFIX, search_from)
-            if pos < 0:
-                return -1
-            close = buffer.find(">", pos + prefix_len)
-            if close < 0:
-                return -1
-            attrs = buffer[pos + prefix_len : close]
-            name = extract_attr_value(attrs, "name")
-            if name and normalize_entml_name(name):
-                return pos
-            search_from = close + 1
+    def _find_complete_invoke_open(
+        self,
+        buffer: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> int:
+        """返回首个可解析 ``<entml:invoke`` 起始下标；否则 ``-1``。"""
+        schema_index = _build_param_schema_index(tools) if tools else None
+        known = resolve_known_tool_names(tools, schema_index)
+        return find_actionable_entml_invoke_open(buffer, known_names=known)
 
     def parse(
         self,
@@ -282,6 +291,8 @@ class EntmlProtocol(ToolProtocol):
             )
             if unclosed_open_at >= 0:
                 parse_text = text[:unclosed_open_at]
+        schema_index = _build_param_schema_index(tools) if tools else None
+        known = resolve_known_tool_names(tools, schema_index)
         tool_calls = parse_entml_tool_calls(parse_text, tools, schema_index)
         tool_block_calls: List[Dict[str, Any]] = []
         if include_tool_blocks:
@@ -297,8 +308,8 @@ class EntmlProtocol(ToolProtocol):
         # 须在移除 invoke 之前剥离伪 history，且须晚于已解析的 ``<tool>`` 块剥离。
         clean, _ = strip_fake_history_markup(clean)
         if tool_calls:
-            clean = strip_actionable_entml_invoke_blocks(clean)
-        clean = strip_tool_entml_residue(clean)
+            clean = strip_actionable_entml_invoke_blocks(clean, known_names=known)
+        clean = strip_tool_entml_residue(clean, known_names=known)
         return (clean, normalize_tool_calls(tool_calls, tools))
 
     def parse_fragment(
@@ -313,9 +324,15 @@ class EntmlProtocol(ToolProtocol):
         """user 消息：仅去掉 ``entml:`` 前缀，不做其它剥离。"""
         return strip_entml_from_content(content)
 
-    def clean_tool_tags(self, content: str) -> str:
+    def clean_tool_tags(
+        self,
+        content: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> str:
         """仅剥离工具相关标签残留，保留 thinking；并移除伪 history 块。"""
-        cleaned = strip_tool_entml_residue(content)
+        schema_index = _build_param_schema_index(tools) if tools else None
+        known = resolve_known_tool_names(tools, schema_index)
+        cleaned = strip_tool_entml_residue(content, known_names=known)
         cleaned, _ = strip_fake_history_markup(cleaned)
         return cleaned
 

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -15,6 +15,7 @@ from .entml_patterns import (
     iter_actionable_entml_invoke_blocks,
     normalize_entml_name,
     parse_sub_tags,
+    resolve_known_tool_names,
     split_mangled_json_param_tail,
     synthetic_close_invoke_body,
 )
@@ -143,7 +144,10 @@ def parse_entml_tool_calls(
     schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]],
 ) -> List[Dict[str, Any]]:
     tool_calls: List[Dict[str, Any]] = []
-    for _start, _end, attrs, body in iter_actionable_entml_invoke_blocks(text):
+    known = resolve_known_tool_names(tools, schema_index)
+    for _start, _end, attrs, body in iter_actionable_entml_invoke_blocks(
+        text, known_names=known
+    ):
         name = extract_attr_value(attrs, "name")
         if not name:
             continue

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import json
 import re
-from typing import Any, Dict, Iterator, List, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple
 
 from .entml_schema import coerce_entml_parameter_value
 
@@ -116,8 +116,37 @@ def is_placeholder_invoke_name(name: str) -> bool:
     return not n or "$" in n
 
 
-def entml_invoke_open_is_actionable(buffer: str, pos: int) -> bool:
-    """``pos`` 处 ``<entml:invoke`` 是否为已闭合且含真实 name 的工具开标签。"""
+def resolve_known_tool_names(
+    tools: Optional[List[Dict[str, Any]]] = None,
+    schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]] = None,
+) -> Optional[Set[str]]:
+    """从 tools / schema_index 解析已知工具名；无约束时返回 ``None``。"""
+    if schema_index:
+        return {normalize_entml_name(str(k)) for k in schema_index.keys()}
+    names: Set[str] = set()
+    for tool in tools or []:
+        fn = tool.get("function") or {}
+        name = fn.get("name")
+        if name:
+            names.add(normalize_entml_name(str(name)))
+    return names if names else None
+
+
+def _name_is_known(name: str, known_names: Optional[Set[str]]) -> bool:
+    if known_names is None:
+        return True
+    if not known_names:
+        return False
+    return normalize_entml_name(name) in known_names
+
+
+def entml_invoke_open_is_actionable(
+    buffer: str,
+    pos: int,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> 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))
@@ -128,29 +157,60 @@ def entml_invoke_open_is_actionable(buffer: str, pos: int) -> bool:
     if not name:
         return False
     name = normalize_entml_name(name)
-    return bool(name) and not is_placeholder_invoke_name(name)
+    if not name or is_placeholder_invoke_name(name):
+        return False
+    return _name_is_known(name, known_names)
 
 
-def entml_invoke_open_may_be_streaming(buffer: str, pos: int) -> bool:
-    """``pos`` 处 ``<entml:invoke`` 是否仍可能长成真实工具开标签（非 prose 提及）。"""
+def entml_invoke_open_may_be_streaming(
+    buffer: str,
+    pos: int,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> 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
+    return entml_invoke_open_is_actionable(buffer, pos, known_names=known_names)
+
+
+def find_actionable_entml_invoke_open(
+    buffer: str,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> int:
+    """返回首个可解析 ``<entml:invoke`` 起始下标；否则 ``-1``。"""
+    if not buffer:
+        return -1
+    search_from = 0
+    prefix_len = len(_INVOKE_OPEN_PREFIX)
+    while search_from < len(buffer):
+        pos = buffer.find(_INVOKE_OPEN_PREFIX, search_from)
+        if pos < 0:
+            return -1
+        if entml_invoke_open_is_actionable(buffer, pos, known_names=known_names):
+            return pos
+        gt = buffer.find(">", pos + prefix_len)
+        search_from = (gt + 1) if gt >= 0 else (pos + prefix_len)
+    return -1
 
 
-def _actionable_invoke_open_before_close(content: str, close_pos: int) -> bool:
+def _actionable_invoke_open_before_close(
+    content: str,
+    close_pos: int,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> bool:
     """``close_pos`` 处的 ``</entml:invoke>`` 是否闭合带真实 name 的开标签。"""
     search = close_pos - 1
     while search >= 0:
         pos = content.rfind(_INVOKE_OPEN_PREFIX, 0, search + 1)
         if pos < 0:
             return False
-        if entml_invoke_open_is_actionable(content, pos):
+        if entml_invoke_open_is_actionable(content, pos, known_names=known_names):
             gt = content.find(">", pos)
             if gt < 0 or gt >= close_pos:
                 search = pos - 1
@@ -164,17 +224,26 @@ def _actionable_invoke_open_before_close(content: str, close_pos: int) -> bool:
     return False
 
 
-def _invoke_close_should_strip(content: str, close_pos: int) -> bool:
+def _invoke_close_should_strip(
+    content: str,
+    close_pos: int,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> bool:
     """是否应剥离 ``</entml:invoke>``（孤儿噪声或真实工具块残留）。"""
-    if _actionable_invoke_open_before_close(content, close_pos):
+    if _actionable_invoke_open_before_close(content, close_pos, known_names=known_names):
         return True
     open_pos = content.rfind(_INVOKE_OPEN_PREFIX, 0, close_pos)
     if open_pos < 0:
         return True
-    return entml_invoke_open_is_actionable(content, open_pos)
+    return entml_invoke_open_is_actionable(content, open_pos, known_names=known_names)
 
 
-def iter_actionable_entml_invoke_blocks(text: str) -> Iterator[Tuple[int, int, str, str]]:
+def iter_actionable_entml_invoke_blocks(
+    text: str,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> Iterator[Tuple[int, int, str, str]]:
     """迭代含真实 ``name`` 的完整 ``<entml:invoke>…</entml:invoke>`` 块。"""
     if not text:
         return
@@ -185,8 +254,9 @@ def iter_actionable_entml_invoke_blocks(text: str) -> Iterator[Tuple[int, int, s
         pos = text.find(_INVOKE_OPEN_PREFIX, search_from)
         if pos < 0:
             break
-        if not entml_invoke_open_is_actionable(text, pos):
-            search_from = pos + prefix_len
+        if not entml_invoke_open_is_actionable(text, pos, known_names=known_names):
+            gt = text.find(">", pos + prefix_len)
+            search_from = (gt + 1) if gt >= 0 else (pos + prefix_len)
             continue
         gt = text.find(">", pos + prefix_len)
         if gt < 0:
@@ -200,30 +270,40 @@ def iter_actionable_entml_invoke_blocks(text: str) -> Iterator[Tuple[int, int, s
         search_from = close + close_len
 
 
-def strip_actionable_entml_invoke_blocks(text: str) -> str:
+def strip_actionable_entml_invoke_blocks(
+    text: str,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> str:
     """仅剥离含真实 ``name`` 的 invoke 块；保留 prose ``<entml:invoke>`` 提及。"""
     if not text:
         return text
     parts: List[str] = []
     last = 0
-    for start, end, _attrs, _body in iter_actionable_entml_invoke_blocks(text):
+    for start, end, _attrs, _body in iter_actionable_entml_invoke_blocks(
+        text, known_names=known_names
+    ):
         parts.append(text[last:start])
         last = end
     parts.append(text[last:])
     return "".join(parts)
 
 
-def _strip_orphan_invoke_tags(content: str) -> str:
+def _strip_orphan_invoke_tags(
+    content: str,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> 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("</"):
-            if _invoke_close_should_strip(content, match.start()):
+            if _invoke_close_should_strip(content, match.start(), known_names=known_names):
                 return ""
             return tag
-        if entml_invoke_open_is_actionable(content, match.start()):
+        if entml_invoke_open_is_actionable(content, match.start(), known_names=known_names):
             return ""
         return tag
 
@@ -446,13 +526,17 @@ def strip_legacy_function_calls_wrapper(text: str) -> str:
     return out
 
 
-def strip_tool_entml_residue(content: str) -> str:
+def strip_tool_entml_residue(
+    content: str,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> str:
     """剥离工具相关 entml 标签残留，保留 thinking 与非工具 prose 提及。"""
     if not content:
         return content
     cleaned = _TOOL_WRAPPER_PAIR_RE.sub("", content)
-    cleaned = strip_actionable_entml_invoke_blocks(cleaned)
-    cleaned = _strip_orphan_invoke_tags(cleaned)
+    cleaned = strip_actionable_entml_invoke_blocks(cleaned, known_names=known_names)
+    cleaned = _strip_orphan_invoke_tags(cleaned, known_names=known_names)
     cleaned = _strip_orphan_non_invoke_tool_tags(cleaned)
     cleaned = _EMPTY_FENCE_RE.sub("", cleaned)
     cleaned = _FENCE_ONLY_LINE_RE.sub("", cleaned)

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/protocols/entml_stream/body.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import json
 import re
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from echotools.exec.fncall.protocols.entml_patterns import (
     BARE_INVOKE_CHILD_OPEN_RE,
@@ -59,7 +59,11 @@ def _strip_incomplete_child_close_suffix(value: str, key: str) -> str:
     return value
 
 
-def split_invoke_open(buffer: str) -> Optional[Tuple[str, int]]:
+def split_invoke_open(
+    buffer: str,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> Optional[Tuple[str, int]]:
     """返回当前正在流式写入的 invoke（最后一个有效开标签）。"""
     search_from = 0
     prefix_len = len(_INVOKE_OPEN_PREFIX)
@@ -68,6 +72,14 @@ def split_invoke_open(buffer: str) -> Optional[Tuple[str, int]]:
         pos = buffer.find(_INVOKE_OPEN_PREFIX, search_from)
         if pos < 0:
             break
+        from echotools.exec.fncall.protocols.entml_patterns import (
+            entml_invoke_open_is_actionable,
+        )
+
+        if not entml_invoke_open_is_actionable(buffer, pos, known_names=known_names):
+            gt = buffer.find(">", pos + prefix_len)
+            search_from = (gt + 1) if gt >= 0 else (pos + prefix_len)
+            continue
         gt = buffer.find(">", pos + prefix_len)
         if gt < 0:
             break

{echotools-2.3.88 → echotools-2.3.89}/src/echotools/exec/fncall/protocols/entml_think/hold.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 import re
-from typing import List, Optional, Tuple
+from typing import List, Optional, Set, Tuple
 
 from echotools.exec.fncall.protocols.entml_patterns import (
     entml_invoke_open_may_be_streaming,
-    extract_attr_value,
-    normalize_entml_name,
+    find_actionable_entml_invoke_open,
 )
 
 THINKING_BLOCK_RE = re.compile(
@@ -39,24 +38,13 @@ _LEADING_HOLD_PREFIXES = _AMBIGUOUS_ENTML_PREFIXES + _ORPHAN_CLOSE_PREFIXES + (
 )
 
 
-def find_complete_entml_invoke_open(buffer: str) -> int:
-    """返回首个含 name 且已闭合 ``>`` 的 ``<entml:invoke`` 起始下标；否则 -1。"""
-    if not buffer:
-        return -1
-    search_from = 0
-    prefix_len = len(_INVOKE_PREFIX)
-    while True:
-        pos = buffer.find(_INVOKE_PREFIX, search_from)
-        if pos < 0:
-            return -1
-        close = buffer.find(">", pos + prefix_len)
-        if close < 0:
-            return -1
-        attrs = buffer[pos + prefix_len : close]
-        name = extract_attr_value(attrs, "name")
-        if name and normalize_entml_name(name):
-            return pos
-        search_from = close + 1
+def find_complete_entml_invoke_open(
+    buffer: str,
+    *,
+    known_names: Optional[set[str]] = None,
+) -> int:
+    """返回首个可解析 ``<entml:invoke`` 起始下标；否则 ``-1``。"""
+    return find_actionable_entml_invoke_open(buffer, known_names=known_names)
 
 
 
@@ -153,13 +141,19 @@ def _hold_thinking_open_prefixes(
     return safe, ""
 
 
-def _hold_ambiguous_tool_markup(buffer: str) -> Tuple[str, str]:
+def _hold_ambiguous_tool_markup(
+    buffer: str,
+    *,
+    known_names: Optional[Set[str]] = None,
+) -> Tuple[str, str]:
     """thinking 块内：hold 可能长成真实工具调用的 markup（非 prose ``<entml:invoke>`` 提及）。"""
     if not buffer:
         return "", ""
     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 invoke_pos >= 0 and entml_invoke_open_may_be_streaming(
+        buffer, invoke_pos, known_names=known_names
+    ):
         if hold_from is None or invoke_pos < hold_from:
             hold_from = invoke_pos
     for prefix in _AMBIGUOUS_ENTML_PREFIXES: