echotools 2.3.43__tar.gz → 2.3.45__tar.gz

{echotools-2.3.43 → echotools-2.3.45}/PKG-INFO

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

{echotools-2.3.43 → echotools-2.3.45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "echotools"
-version = "2.3.43"
+version = "2.3.45"
 description = "通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链"
 readme = "docs/README.md"
 requires-python = ">=3.8"
@@ -103,6 +103,7 @@ ignore_errors = true
 
 [tool.pytest.ini_options]
 testpaths = ["src/tests"]
+pythonpath = ["src", "src/tests"]
 asyncio_mode = "auto"
 addopts = ["--strict-markers", "--tb=short"]
 markers = [

{echotools-2.3.43 → echotools-2.3.45}/src/echotools/exec/fncall/parsers/stream.py

@@ -176,37 +176,40 @@ class FncallStreamParser:
         combined = self._waiting_tail + chunk
         self._waiting_tail = ""
 
-        if self._thinking_filter is not None:
-            from echotools.exec.fncall.protocols.entml_think.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
+        # 已进入 thinking 块时，块内不做 invoke 检测。
+        if self._thinking_filter is not None and self._thinking_filter.in_open_thinking():
+            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)
-            if safe:
-                self._emit_text(safe)
-            self._waiting_tail = remain
+        if found:
+            if pos > 0:
+                # 工具标签前的正文仍可能含 thinking，走过滤器。
+                self._emit_text(combined[:pos])
+            self._fncall_buf = combined[pos:]
+            self._detected = True
+            self._state = self.IN_FUNCTION_CALLS
+            if self._is_call_closed():
+                self._state = self.DONE
             return
 
-        if pos > 0:
-            self._emit_text(combined[:pos])
-
-        self._fncall_buf = combined[pos:]
-        self._detected = True
-        self._state = self.IN_FUNCTION_CALLS
+        # 无完整工具开标签时，再处理未闭合 thinking / 思考开标签 holdback。
+        # 必须放在 detect_start 之后：否则 `<entml:function_calls>\n<en` 会被
+        # 尾部 `<en` 误判为 thinking 前缀，导致 invoke 内容被截断。
+        if self._thinking_filter is not None:
+            from echotools.exec.fncall.protocols.entml_think.parse import (
+                has_unclosed_entml_thinking,
+            )
+            if has_unclosed_entml_thinking(combined):
+                self._feed_waiting_thinking_plain(combined)
+                return
 
-        # 检查是否已闭合（单块内完成）
-        if self._is_call_closed():
-            self._state = self.DONE
+        safe, remain = self._split_safe_text(combined, trigger_tags)
+        if safe:
+            self._emit_text(safe)
+        self._waiting_tail = remain
 
     def _is_call_closed(self) -> bool:
         """检测 fncall 缓冲区中是否包含结束标记。"""
@@ -218,12 +221,15 @@ class FncallStreamParser:
                 return True
         return False
 
-    def feed(self, chunk: str) -> None:
-        """喂入新的流式文本块。DONE 或 finalize 后调用静默忽略。"""
+    def feed(self, chunk: str) -> List[Dict[str, Any]]:
+        """喂入新的流式文本块，返回本轮新完成的 tool_calls（可空列表）。
+
+        DONE 或 finalize 后调用静默忽略并返回 ``[]``。
+        """
         if not chunk or self._state == self.DONE:
-            return
+            return []
         if self._finalized_result is not None:
-            return
+            return []
 
         self._raw_buf += chunk
 
@@ -234,6 +240,12 @@ class FncallStreamParser:
             if self._is_call_closed():
                 self._state = self.DONE
 
+        return self.get_ready_tool_calls()
+
+    def _assembly_for_tool_parse(self) -> str:
+        """可供工具解析的已缓冲文本（不含 thinking 过滤器内部 pending）。"""
+        return "".join(self._text_parts) + self._waiting_tail + self._fncall_buf
+
     def finalize(self) -> Tuple[str, List[Dict[str, Any]]]:
         """结束流式解析，返回 (清理后文本, tool_calls 列表)。幂等。"""
         if self._finalized_result is not None:
@@ -253,12 +265,18 @@ class FncallStreamParser:
                 else:
                     self._text_parts.append(part)
 
-        if not self._detected:
-            full_text = "".join(self._text_parts)
-            clean_text, tool_calls = self._protocol.parse(full_text, self._tools)
-        else:
-            clean_text = "".join(self._text_parts).strip()
-            _, tool_calls = self._protocol.parse(self._fncall_buf, self._tools)
+        # 统一从「可见正文 + fncall 缓冲」解析，避免漏检；thinking 已在过滤器中剥离
+        assembled = "".join(self._text_parts) + self._fncall_buf
+        clean_text, tool_calls = self._protocol.parse(assembled, self._tools)
+
+        clean_fn = getattr(self._protocol, "clean_tool_tags", None)
+        if callable(clean_fn):
+            clean_text = clean_fn(clean_text)
+        elif getattr(self._protocol, "id", None) == "entml":
+            from echotools.exec.fncall.protocols.entml_patterns import (
+                strip_tool_entml_residue,
+            )
+            clean_text = strip_tool_entml_residue(clean_text)
 
         # 兜底：剥离残留 <entml:thinking>（holdback 边界/分片异常时）
         if self._thinking_filter is not None and clean_text:
@@ -298,16 +316,20 @@ class FncallStreamParser:
     def get_ready_tool_calls(self) -> List[Dict[str, Any]]:
         """返回新完成的 tool_calls（增量，每次调用只返回上次调用之后新增的）。
 
-        适用于在流式阶段实时发送已解析完毕的 tool call，无需等待整个 buffer 就绪。
+        流式阶段可在每次 ``feed`` 后调用，无需等待整个 buffer 结束。
         """
-        if self._state not in (self.IN_FUNCTION_CALLS, self.DONE):
-            return []
-        try:
-            _, all_calls = self._protocol.parse(self._fncall_buf, self._tools)
-        except Exception:
-            return []
+        if self._finalized_result is not None:
+            _, all_calls = self._finalized_result
+        else:
+            try:
+                _, all_calls = self._protocol.parse(
+                    self._assembly_for_tool_parse(),
+                    self._tools,
+                )
+            except Exception:
+                return []
         if len(all_calls) <= self._emitted_invoke_count:
             return []
-        new_calls = all_calls[self._emitted_invoke_count:]
+        new_calls = all_calls[self._emitted_invoke_count :]
         self._emitted_invoke_count = len(all_calls)
         return new_calls

{echotools-2.3.43 → echotools-2.3.45}/src/echotools/exec/fncall/prompt/inject.py

@@ -22,7 +22,9 @@ from echotools.exec.fncall.protocols.entml import (
     format_entml_conversation_history,
     format_entml_current_user_message,
 )
-from echotools.exec.fncall.protocols.entml_think.core import build_entml_thinking_section
+from echotools.exec.fncall.protocols.entml_think.core import (
+    build_entml_thinking_section,
+)
 from echotools.exec.fncall.protocols.entml_think.hist import (
     apply_thinking_history_policy,
     parse_include_thinking_in_history,

{echotools-2.3.43 → echotools-2.3.45}/src/echotools/exec/fncall/protocols/entml.py

@@ -18,8 +18,13 @@ 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_patterns import BLOCK_RE
-from echotools.exec.fncall.protocols.entml_think.core import build_entml_thinking_section
+from echotools.exec.fncall.protocols.entml_patterns import (
+    BLOCK_RE,
+    strip_tool_entml_residue,
+)
+from echotools.exec.fncall.protocols.entml_think.core import (
+    build_entml_thinking_section,
+)
 from echotools.exec.fncall.protocols.entml_tools import format_entml_tool_descs
 from echotools.exec.fncall.shared.coercion import _build_param_schema_index
 from echotools.exec.fncall.shared.normalization import (
@@ -131,10 +136,19 @@ class EntmlProtocol(ToolProtocol):
 
     _TRIGGER = "<entml:invoke>"
     _TRIGGER_PREFIX = "<entml:invoke"
+    _WRAPPER_PREFIX = "<entml:function_calls"
+    _THINKING_PREFIX = "<entml:thinking"
 
     def get_trigger_tags(self) -> List[str]:
-        # 同时声明带/不带 ``>`` 的形式，便于流式 holdback 覆盖属性段
-        return [self._TRIGGER, self._TRIGGER_PREFIX]
+        # invoke / function_calls / thinking 前缀一并 holdback，避免 `<e` 歧义被提前吐出
+        return [
+            self._TRIGGER,
+            self._TRIGGER_PREFIX,
+            self._WRAPPER_PREFIX,
+            f"{self._WRAPPER_PREFIX}>",
+            self._THINKING_PREFIX,
+            f"{self._THINKING_PREFIX}>",
+        ]
 
     def get_stream_end_tags(self) -> List[str]:
         """新格式无外层 wrapper，不自动关闭流，由 finalize() 统一解析。"""
@@ -187,14 +201,18 @@ class EntmlProtocol(ToolProtocol):
         return "\n\n".join(sections)
 
     def detect_start(self, buffer: str) -> Tuple[bool, int]:
-        pos = buffer.find(self._TRIGGER_PREFIX)
-        if pos < 0:
+        candidates: List[int] = []
+        for prefix in (self._WRAPPER_PREFIX, self._TRIGGER_PREFIX):
+            pos = buffer.find(prefix)
+            if pos < 0:
+                continue
+            close = buffer.find(">", pos + len(prefix))
+            if close < 0:
+                continue
+            candidates.append(pos)
+        if not candidates:
             return (False, -1)
-        # 确保是完整的开标签（name=" 属性存在）
-        close = buffer.find(">", pos + len(self._TRIGGER_PREFIX))
-        if close < 0:
-            return (False, -1)
-        return (True, pos)
+        return (True, min(candidates))
 
     def parse(
         self,
@@ -205,7 +223,9 @@ class EntmlProtocol(ToolProtocol):
         tool_calls = parse_entml_tool_calls(text, tools, schema_index)
         clean = text
         if tool_calls:
-            clean = BLOCK_RE.sub("", text).strip()
+            clean = BLOCK_RE.sub("", text)
+        # 无论是否解析成功，都剥离工具相关残留，避免标签泄露；thinking 保留给后续 split。
+        clean = strip_tool_entml_residue(clean)
         return (clean, normalize_tool_calls(tool_calls, tools))
 
     def parse_fragment(
@@ -219,6 +239,10 @@ class EntmlProtocol(ToolProtocol):
     def clean_tags(self, content: str) -> str:
         return strip_entml_from_content(content)
 
+    def clean_tool_tags(self, content: str) -> str:
+        """仅剥离工具相关标签残留，保留 thinking。"""
+        return strip_tool_entml_residue(content)
+
     def format_assistant_tool_calls(
         self,
         tool_calls: List[Dict[str, Any]],

{echotools-2.3.43 → echotools-2.3.45}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -7,7 +7,9 @@ from .entml_patterns import (
     INVOKE_RE,
     PARAM_RE,
     PARAMETERS_RE,
+    extract_attr_value,
     extract_parameter_type_attr,
+    normalize_entml_name,
     parse_sub_tags,
 )
 from .entml_values import coerce_entml_arguments, coerce_entml_parameter_value
@@ -36,9 +38,12 @@ def parse_invoke_args(
 
     args: Dict[str, Any] = {}
     for param_m in PARAM_RE.finditer(body):
-        pname = param_m.group(1).strip()
-        attrs = param_m.group(2) or ""
-        pval = param_m.group(3)
+        attrs = param_m.group(1) or ""
+        pname = extract_attr_value(attrs, "name")
+        if not pname:
+            continue
+        pname = normalize_entml_name(pname)
+        pval = (param_m.group(2) or "").strip()
         type_hint = extract_parameter_type_attr(attrs)
         pschema = func_props.get(pname) or {}
         args[pname] = coerce_entml_parameter_value(
@@ -57,7 +62,11 @@ def parse_entml_tool_calls(
 ) -> List[Dict[str, Any]]:
     tool_calls: List[Dict[str, Any]] = []
     for invoke_m in INVOKE_RE.finditer(text):
-        name = invoke_m.group(1).strip()
+        attrs = invoke_m.group(1) or ""
+        name = extract_attr_value(attrs, "name")
+        if not name:
+            continue
+        name = normalize_entml_name(name)
         args = parse_invoke_args(invoke_m.group(2), name, schema_index)
         arguments = json.dumps(args, ensure_ascii=False)
         tool_calls.append(

echotools-2.3.45/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, Optional
+
+from .entml_values import coerce_entml_parameter_value
+
+BLOCK_RE = re.compile(
+    r"<entml:invoke\b[^>]*>[\s\S]*?</entml:invoke>",
+    re.DOTALL,
+)
+# 允许 name 前后有其它属性；单/双引号均可。
+INVOKE_RE = re.compile(
+    r"<entml:invoke\b([^>]*)>([\s\S]*?)</entml:invoke>",
+    re.DOTALL,
+)
+# 允许 name / type 等属性任意顺序；单/双引号均可。
+PARAM_RE = re.compile(
+    r"<entml:parameter\b([^>]*)>([\s\S]*?)</entml:parameter>",
+    re.DOTALL,
+)
+_ATTR_NAME_RE = re.compile(
+    r"""\bname\s*=\s*(?P<q>["'])(?P<v>.*?)(?P=q)""",
+    re.DOTALL,
+)
+_PARAM_TYPE_ATTR_RE = re.compile(
+    r"""\btype\s*=\s*(?P<q>["'])(?P<v>.*?)(?P=q)"""
+)
+PARAMETERS_RE = re.compile(
+    r"<entml:parameters>([\s\S]*?)</entml:parameters>",
+    re.DOTALL,
+)
+SUB_TAG_RE = re.compile(
+    r"<([^>]+)>([\s\S]*?)</\1>",
+    re.DOTALL,
+)
+# 工具相关外壳 / 残留（不含 thinking，留给 split_entml_thinking）。
+_TOOL_WRAPPER_PAIR_RE = re.compile(
+    r"<entml:function_calls\b[^>]*>[\s\S]*?</entml:function_calls>",
+    re.DOTALL,
+)
+_TOOL_ORPHAN_TAG_RE = re.compile(
+    r"</?entml:(?:function_calls|invoke|parameter|parameters)\b[^>]*/?>",
+    re.DOTALL,
+)
+_EMPTY_FENCE_RE = re.compile(
+    r"```(?:xml|entml|text)?\s*```",
+    re.IGNORECASE,
+)
+_FENCE_ONLY_LINE_RE = re.compile(
+    r"^\s*```(?:xml|entml|text)?\s*$",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+
+def extract_attr_value(attrs: str, attr_name: str = "name") -> Optional[str]:
+    """从标签属性串中提取 name/type 等（支持单双引号）。"""
+    if not attrs:
+        return None
+    if attr_name == "name":
+        match = _ATTR_NAME_RE.search(attrs)
+    elif attr_name == "type":
+        match = _PARAM_TYPE_ATTR_RE.search(attrs)
+    else:
+        pattern = re.compile(
+            rf"""\b{re.escape(attr_name)}\s*=\s*(?P<q>["'])(?P<v>.*?)(?P=q)"""
+        )
+        match = pattern.search(attrs)
+    if not match:
+        return None
+    return match.group("v").strip()
+
+
+def normalize_entml_name(name: str) -> str:
+    """还原 markdown 转义下划线等常见名称噪声。"""
+    if not name:
+        return ""
+    return name.replace("\\_", "_").replace("\\-", "-").strip()
+
+
+def extract_parameter_type_attr(attrs: str) -> Optional[str]:
+    """从 parameter 开标签属性中提取 type=\"...\"。"""
+    return extract_attr_value(attrs or "", "type")
+
+
+def parse_sub_tags(
+    content: str,
+    schema_index: Optional[Dict[str, Any]] = None,
+    func_name: str = "",
+) -> Dict[str, Any]:
+    """解析 <entml:parameters> 内的子标签，返回参数字典。"""
+    args: Dict[str, Any] = {}
+    for m in SUB_TAG_RE.finditer(content):
+        pname = m.group(1).strip()
+        pval = m.group(2).strip()
+        pschema = schema_index.get(func_name, {}).get(pname, {}) if schema_index else {}
+        args[pname] = coerce_entml_parameter_value(pval, pschema or None)
+    return args
+
+
+def strip_tool_entml_residue(content: str) -> str:
+    """剥离工具相关 entml 标签残留，保留 thinking 等非工具标签。"""
+    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 = _EMPTY_FENCE_RE.sub("", cleaned)
+    cleaned = _FENCE_ONLY_LINE_RE.sub("", cleaned)
+    # 折叠因剥离产生的多余空行
+    cleaned = re.sub(r"[ \t]+\n", "\n", cleaned)
+    cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
+    return cleaned.strip()

{echotools-2.3.43 → echotools-2.3.45}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -10,6 +10,13 @@ THINKING_BLOCK_RE = re.compile(
 
 _THINKING_OPEN_PREFIX = "<entml:thinking"
 _THINKING_CLOSE = "</entml:thinking>"
+# 与 thinking 共享 `<entml:` 前缀的其它标签：歧义 holdback 应交由工具流式状态机处理
+_AMBIGUOUS_ENTML_PREFIXES = (
+    "<entml:invoke",
+    "<entml:function_calls",
+    "<entml:parameter",
+    "<entml:parameters",
+)
 
 
 def has_unclosed_entml_thinking(text: str) -> bool:
@@ -32,8 +39,14 @@ def has_unclosed_entml_thinking(text: str) -> bool:
     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
+        if not (
+            _THINKING_OPEN_PREFIX.startswith(suffix) and suffix != _THINKING_OPEN_PREFIX
+        ):
+            continue
+        # `<e` / `<entml:` 等对 invoke 同样是真前缀 → 不在此抢占
+        if any(other.startswith(suffix) for other in _AMBIGUOUS_ENTML_PREFIXES):
+            continue
+        return True
     return False
 
 

{echotools-2.3.43 → echotools-2.3.45}/src/echotools/exec/fncall/shared/coercion.py

@@ -257,9 +257,11 @@ def _coerce_param_value(raw: str, schema: Dict[str, Any]) -> Any:
         return parsed
 
     if effective_type == "string":
-        if isinstance(parsed, str):
-            return parsed
-        return _coerce_to_string(parsed)
+        # string 字段保留原文；仅当整段是 JSON 字符串字面量 ("...") 时才解包
+        if len(stripped) >= 2 and stripped[0] == '"' and stripped[-1] == '"':
+            if isinstance(parsed, str):
+                return parsed
+        return stripped
 
     if effective_type == "integer":
         return _coerce_to_integer(stripped, parsed)

{echotools-2.3.43 → echotools-2.3.45}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.43 → echotools-2.3.45}/src/echotools.egg-info/SOURCES.txt

@@ -148,6 +148,7 @@ src/echotools/plat/sdk/__init__.py
 src/echotools/plat/sdk/facade.py
 src/tests/bench_import.py
 src/tests/conftest.py
+src/tests/test_adversarial_stream_splits.py
 src/tests/test_cache_retry.py
 src/tests/test_completion.py
 src/tests/test_config.py
@@ -160,6 +161,8 @@ src/tests/test_dispatch_race.py
 src/tests/test_entml_protocol.py
 src/tests/test_entml_thinking_history.py
 src/tests/test_entml_thinking_parse.py
+src/tests/test_entml_tool_parse_leak.py
+src/tests/test_entml_tool_pipeline.py
 src/tests/test_entml_tools.py
 src/tests/test_errors.py
 src/tests/test_errors_common.py
@@ -182,7 +185,11 @@ src/tests/test_proxy.py
 src/tests/test_proxy_selector.py
 src/tests/test_runtime.py
 src/tests/test_scheduler.py
+src/tests/test_simulated_llm_tool_parse.py
+src/tests/test_stream_realtime_parse.py
 src/tests/test_tracing.py
 src/tests/test_usage.py
 src/tests/test_web.py
-src/tests/test_web_broker.py
+src/tests/test_web_broker.py
+src/tests/fixtures/__init__.py
+src/tests/fixtures/simulated_llm_tool_responses.py