echotools 2.3.87__tar.gz → 2.3.89__tar.gz

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

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

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

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

{echotools-2.3.87 → 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.87 → 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.87 → 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.87 → 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.87 → 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.87 → echotools-2.3.89}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -11,9 +11,11 @@ from .entml_patterns import (
     PARAMETERS_RE,
     extract_attr_value,
     extract_parameter_type_attr,
+    invoke_structural_gap_text,
     iter_actionable_entml_invoke_blocks,
     normalize_entml_name,
     parse_sub_tags,
+    resolve_known_tool_names,
     split_mangled_json_param_tail,
     synthetic_close_invoke_body,
 )
@@ -25,8 +27,9 @@ def _parse_direct_child_tags(
     args: Dict[str, Any],
     func_props: Dict[str, Dict[str, Any]],
 ) -> None:
-    """模型用 ``<key>value</key>`` 代替 ``<parameter name=\"key\">``。"""
-    for match in INVOKE_DIRECT_CHILD_RE.finditer(body):
+    """模型用 ``<key>value</key>`` 代替 ``<parameter name=\"key\">``（仅 structural gap）。"""
+    gap_text = invoke_structural_gap_text(body)
+    for match in INVOKE_DIRECT_CHILD_RE.finditer(gap_text):
         key = normalize_entml_name(match.group(1))
         if not key or key.lower() in INVOKE_DIRECT_CHILD_SKIP or key in args:
             continue
@@ -42,7 +45,8 @@ def _parse_bare_invoke_children(
     args: Dict[str, Any],
     func_props: Dict[str, Dict[str, Any]],
 ) -> None:
-    for match in BARE_INVOKE_CHILD_RE.finditer(body):
+    gap_text = invoke_structural_gap_text(body)
+    for match in BARE_INVOKE_CHILD_RE.finditer(gap_text):
         key = normalize_entml_name(match.group(1))
         if not key or key in args:
             continue
@@ -140,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