echotools 2.3.87__tar.gz → 2.3.88__tar.gz

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

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

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

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

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

@@ -11,6 +11,7 @@ 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,
@@ -25,8 +26,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 +44,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

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

@@ -15,17 +15,22 @@ INVOKE_RE = re.compile(
     r"<entml:invoke\b([^>]*)>([\s\S]*?)</entml:invoke>",
     re.DOTALL,
 )
+# invoke 内直接子元素：<pattern>v</pattern>、<-n>true</-n>（标签名即参数名）
+_INVOKE_DIRECT_TAG_NAME = r"(?:-\w+|[a-zA-Z_][\w.-]*)"
 # 允许 name / type 等属性任意顺序；单/双引号均可。
-# 闭合标签后必须是下一 parameter / invoke 结束 / parameters 结束。
+# 闭合标签后必须是 invoke 内合法兄弟节点（parameter / entml 子标签 / 直接子元素 / invoke 结束）。
 # 批量解析允许参数块在 body 末尾（$）；流式未闭合 invoke 不允许 $，避免 chunk 落在假闭合上误判。
 # 模型偶发省略 entml: 前缀：<parameter name="...">...</parameter>
 _BARE_PARAM_OPEN_TAG = r"<parameter\b(?![s>])"
 PARAM_OPEN_PATTERN = rf"(?:<entml:parameter\b|{_BARE_PARAM_OPEN_TAG})"
 PARAM_CLOSE_ENTML = "</entml:parameter>"
 PARAM_CLOSE_BARE = "</parameter>"
-# 闭合标签后必须是 invoke 内合法兄弟节点（含裸 description/timeout 等）。
 _INVOKE_SIBLING_OPEN = r"<entml:(?!parameter\b|parameters\b|invoke\b)\w+\b"
-_PARAM_CLOSE_FOLLOWERS = rf"(?:{PARAM_OPEN_PATTERN}|{_INVOKE_SIBLING_OPEN}|</entml:invoke>|</entml:parameters>|{re.escape(PARAM_CLOSE_BARE)})"
+_INVOKE_DIRECT_CHILD_OPEN = rf"<(?!entml:)({_INVOKE_DIRECT_TAG_NAME})\b"
+_PARAM_CLOSE_FOLLOWERS = (
+    rf"(?:{PARAM_OPEN_PATTERN}|{_INVOKE_SIBLING_OPEN}|{_INVOKE_DIRECT_CHILD_OPEN}"
+    rf"|</entml:invoke>|</entml:parameters>|{re.escape(PARAM_CLOSE_BARE)})"
+)
 _PARAM_CLOSE_LOOKAHEAD = rf"(?=\s*{_PARAM_CLOSE_FOLLOWERS})"
 _PARAM_CLOSE_LOOKAHEAD_EOL = rf"(?=\s*(?:{_PARAM_CLOSE_FOLLOWERS}|$))"
 PARAM_RE = re.compile(
@@ -60,8 +65,7 @@ BARE_INVOKE_CHILD_OPEN_RE = re.compile(
     r"<entml:(description|timeout)>([\s\S]*)",
     re.DOTALL | re.IGNORECASE,
 )
-# invoke 内直接子元素：<pattern>v</pattern>、<-n>true</-n>（标签名即参数名）
-_INVOKE_DIRECT_TAG_NAME = r"(?:-\w+|[a-zA-Z_][\w.-]*)"
+# invoke 内直接子元素（完整/未闭合 regex 见下）
 INVOKE_DIRECT_CHILD_RE = re.compile(
     rf"<(?!entml:)({_INVOKE_DIRECT_TAG_NAME})>([\s\S]*?)</\1>",
     re.DOTALL,
@@ -243,6 +247,7 @@ _FOLLOWER_PREFIXES = (
     "</parameter",
     "<entml:description",
     "<entml:timeout",
+    "<",
 )
 
 
@@ -270,6 +275,8 @@ def _parameter_close_follower_ok(after: str, *, allow_end: bool) -> bool:
 
 
 _PARAM_OPEN_TAG_RE = re.compile(rf"{PARAM_OPEN_PATTERN}([^>]*)>", re.IGNORECASE)
+
+
 def synthetic_close_invoke_body(inner: str) -> str:
     """为 force_close / invoke 已闭合但未闭合的 parameter 补齐结构闭合标签。"""
     if not inner:
@@ -316,6 +323,75 @@ def find_valid_parameter_close(body: str, search_from: int = 0, *, allow_end: bo
     return -1
 
 
+def parameter_value_spans(body: str) -> List[Tuple[int, int]]:
+    """``<entml:parameter>`` 值区间（含未闭合 parameter 的 growing tail）。"""
+    if not body:
+        return []
+    spans: List[Tuple[int, int]] = []
+    i = 0
+    while i < len(body):
+        match = _PARAM_OPEN_TAG_RE.search(body, i)
+        if not match:
+            break
+        val_start = match.end()
+        close = find_valid_parameter_close(body, val_start, allow_end=True)
+        if close < 0:
+            spans.append((val_start, len(body)))
+            break
+        spans.append((val_start, close))
+        i = close + parameter_close_at(body, close)
+    return spans
+
+
+def parameter_block_spans(body: str) -> List[Tuple[int, int]]:
+    """完整 ``<entml:parameter …>…</entml:parameter>`` 块（含开闭标签）。"""
+    if not body:
+        return []
+    spans: List[Tuple[int, int]] = []
+    i = 0
+    while i < len(body):
+        match = _PARAM_OPEN_TAG_RE.search(body, i)
+        if not match:
+            break
+        block_start = match.start()
+        val_start = match.end()
+        close = find_valid_parameter_close(body, val_start, allow_end=True)
+        if close < 0:
+            spans.append((block_start, len(body)))
+            break
+        block_end = close + parameter_close_at(body, close)
+        spans.append((block_start, block_end))
+        i = block_end
+    return spans
+
+
+def invoke_structural_gaps(body: str) -> List[Tuple[int, int]]:
+    """invoke 体内可承载备用参数语法的区间（parameter 块之外）。"""
+    if not body:
+        return []
+    blocks = parameter_block_spans(body)
+    if not blocks:
+        return [(0, len(body))]
+    gaps: List[Tuple[int, int]] = []
+    pos = 0
+    for start, end in blocks:
+        if pos < start:
+            gaps.append((pos, start))
+        pos = end
+    if pos < len(body):
+        gaps.append((pos, len(body)))
+    return gaps
+
+
+def invoke_structural_gap_text(body: str) -> str:
+    """parameter 块视为不透明 payload 后，invoke 体剩余可解析文本。"""
+    return "".join(body[s:e] for s, e in invoke_structural_gaps(body))
+
+
+def inside_parameter_value(pos: int, spans: List[Tuple[int, int]]) -> bool:
+    return any(start <= pos < end for start, end in spans)
+
+
 def extract_attr_value(attrs: str, attr_name: str = "name") -> Optional[str]:
     """从标签属性串中提取 name/type 等（支持单双引号）。"""
     if not attrs:

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

@@ -16,6 +16,7 @@ from echotools.exec.fncall.protocols.entml_patterns import (
     extract_attr_value,
     extract_parameter_type_attr,
     find_valid_parameter_close,
+    invoke_structural_gap_text,
     normalize_entml_name,
     parameter_close_at,
     split_mangled_json_param_tail,
@@ -206,46 +207,18 @@ def _parse_bare_invoke_entries(body: str) -> List[Tuple[str, str, bool, Optional
     return entries
 
 
-def _parameter_value_spans(body: str) -> List[Tuple[int, int]]:
-    """``<entml:parameter>`` 值区间（含流式未闭合 parameter 的 growing tail）。"""
-    if not body:
-        return []
-    spans: List[Tuple[int, int]] = []
-    i = 0
-    while i < len(body):
-        match = _PARAM_OPEN_RE.search(body, i)
-        if not match:
-            break
-        val_start = match.end()
-        close = find_valid_parameter_close(body, val_start, allow_end=True)
-        if close < 0:
-            spans.append((val_start, len(body)))
-            break
-        spans.append((val_start, close))
-        i = close + parameter_close_at(body, close)
-    return spans
-
-
-def _inside_parameter_value(pos: int, spans: List[Tuple[int, int]]) -> bool:
-    return any(start <= pos < end for start, end in spans)
-
-
 def _parse_direct_child_entries(body: str) -> List[Tuple[str, str, bool, Optional[str]]]:
     """返回 [(key, value, is_complete, type_hint), ...]（直接子元素标签）。"""
     if not body:
         return []
-    param_spans = _parameter_value_spans(body)
+    gap_text = invoke_structural_gap_text(body)
     tagged: List[Tuple[int, str, str, bool, Optional[str]]] = []
-    for match in INVOKE_DIRECT_CHILD_RE.finditer(body):
-        if _inside_parameter_value(match.start(), param_spans):
-            continue
+    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:
             continue
         tagged.append((match.start(), key, (match.group(2) or "").strip(), True, None))
-    for match in INVOKE_DIRECT_CHILD_OPEN_RE.finditer(body):
-        if _inside_parameter_value(match.start(), param_spans):
-            continue
+    for match in INVOKE_DIRECT_CHILD_OPEN_RE.finditer(gap_text):
         key = normalize_entml_name(match.group(1))
         if not key or key.lower() in INVOKE_DIRECT_CHILD_SKIP:
             continue

{echotools-2.3.87 → echotools-2.3.88}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.87 → echotools-2.3.88}/src/tests/test_entml_protocol.py

@@ -6,6 +6,11 @@ import pytest
 
 from echotools.exec.fncall import get_protocol, inject_fncall
 from echotools.exec.fncall.protocols.entml_invoke import parse_entml_tool_calls
+from echotools.exec.fncall.protocols.entml_patterns import (
+    invoke_structural_gap_text,
+    invoke_structural_gaps,
+    parameter_block_spans,
+)
 from echotools.exec.fncall.protocols.entml_think.core import (
     build_entml_thinking_section,
     default_max_thinking_length_for_level,
@@ -1700,3 +1705,102 @@ def test_write_path_content_hybrid_tool_block() -> None:
     assert "Agent WebUI" in args["content"]
     assert "Phase 1" in args["content"]
 
+
+def test_invoke_structural_gaps_exclude_parameter_blocks() -> None:
+    body = (
+        "pre\n"
+        '<entml:parameter name="content"><span>x</span></entml:parameter>\n'
+        "<path>src/a.py</path>\n"
+        "post"
+    )
+    blocks = parameter_block_spans(body)
+    assert len(blocks) == 1
+    assert body[blocks[0][0] : blocks[0][1]].startswith("<entml:parameter")
+    gaps = invoke_structural_gaps(body)
+    gap_text = invoke_structural_gap_text(body)
+    assert "<span>" not in gap_text
+    assert "<path>src/a.py</path>" in gap_text
+    assert "pre" in gap_text
+    assert "post" in gap_text
+    assert sum(e - s for s, e in gaps) == len(gap_text)
+
+
+def test_write_parameter_payload_opaque_to_alternate_syntax() -> None:
+    """parameter 块内任意类 XML/HTML 标签不得被 invoke 备用语法解析为参数。"""
+    schema_index = _build_param_schema_index(WRITE_TOOLS)
+    sample = (
+        '<entml:invoke name="Write">\n'
+        '<entml:parameter name="path">src/select.js</entml:parameter>\n'
+        '<entml:parameter name="content">'
+        "app.component('core-collapsible', {\n"
+        "  template: [\n"
+        "    '<span class=\"collapsible-arrow\"></span>',\n"
+        "    '<span>{{ title }}</span>',\n"
+        "    '<slot></slot>',\n"
+        "    '<div v-if=\"open\"></div>',\n"
+        "  ].join('\\n')\n"
+        "});\n"
+        "</entml:parameter>\n"
+        "</entml:invoke>"
+    )
+    calls = parse_entml_tool_calls(sample, WRITE_TOOLS, schema_index)
+    assert len(calls) == 1
+    args = json.loads(calls[0]["function"]["arguments"])
+    assert set(args.keys()) == {"file_path", "content"}
+    assert "<slot></slot>" in args["content"]
+    assert "{{ title }}" in args["content"]
+
+
+def test_invoke_mixed_parameter_and_direct_child_syntax() -> None:
+    """structural gap：parameter 与直接子标签可并存，互不污染。"""
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "Grep",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "pattern": {"type": "string"},
+                        "path": {"type": "string"},
+                        "-n": {"type": "boolean"},
+                    },
+                    "required": ["pattern"],
+                },
+            },
+        }
+    ]
+    schema_index = _build_param_schema_index(tools)
+    sample = (
+        '<entml:invoke name="Grep">\n'
+        '<entml:parameter name="pattern">foo|bar</entml:parameter>\n'
+        "<path>src/main.py</path>\n"
+        "<-n>true</-n>\n"
+        "</entml:invoke>"
+    )
+    calls = parse_entml_tool_calls(sample, tools, schema_index)
+    args = json.loads(calls[0]["function"]["arguments"])
+    assert args == {"pattern": "foo|bar", "path": "src/main.py", "-n": True}
+
+
+def test_write_parameter_payload_corpus_req_1785323083() -> None:
+    """回归 req-1785323083：parameter payload 内 markup 不得泄漏为额外参数。"""
+    from pathlib import Path
+
+    sample_path = Path(
+        r"X:/Project/Public/Qwen/logs/responses/req-1785323083-f6847d18c1f9.txt"
+    )
+    if not sample_path.is_file():
+        pytest.skip("corpus file not available")
+    text = sample_path.read_text(encoding="utf-8")
+    proto = get_protocol("entml")
+    _, batch_calls = proto.parse(text, WRITE_TOOLS)
+    write_calls = [c for c in batch_calls if c["function"]["name"] == "Write"]
+    assert len(write_calls) == 1
+    args = json.loads(write_calls[0]["function"]["arguments"])
+    assert "span" not in args
+    assert "slot" not in args
+    assert args["file_path"].endswith("select.js")
+    assert "core-select" in args["content"]
+    assert "<slot></slot>" in args["content"]
+