echotools 2.3.70__tar.gz → 2.3.71__tar.gz

{echotools-2.3.70 → echotools-2.3.71}/PKG-INFO

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

{echotools-2.3.70 → echotools-2.3.71}/pyproject.toml

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

{echotools-2.3.70 → echotools-2.3.71}/src/echotools/exec/fncall/protocols/entml.py

@@ -287,11 +287,11 @@ class EntmlProtocol(ToolProtocol):
         parse_text, _ = strip_fake_history_markup(parse_text)
         tool_calls = parse_entml_tool_calls(parse_text, tools, schema_index)
         clean = text[:unclosed_open_at] if unclosed_open_at >= 0 else text
+        # 须在移除 invoke 之前剥离伪 history，否则未闭合 <tool> 会把 invoke 之后的可见回复误删。
+        clean, _ = strip_fake_history_markup(clean)
         if tool_calls:
             clean = BLOCK_RE.sub("", clean)
-        # 无论是否解析成功，都剥离工具相关残留，避免标签泄露；thinking 保留给后续 split。
         clean = strip_tool_entml_residue(clean)
-        clean, _ = strip_fake_history_markup(clean)
         return (clean, normalize_tool_calls(tool_calls, tools))
 
     def parse_fragment(

{echotools-2.3.70 → echotools-2.3.71}/src/echotools/exec/fncall/shared/history_markup.py

@@ -33,6 +33,15 @@ _ENTML_INVOKE_BLOCK_RE = re.compile(
     r"<entml:invoke\b[^>]*>[\s\S]*?</entml:invoke>",
     re.IGNORECASE,
 )
+_ENTML_FUNCTION_CALLS_OPEN_RE = re.compile(
+    r"<entml:function_calls\b",
+    re.IGNORECASE,
+)
+_ENTML_FUNCTION_CALLS_BLOCK_RE = re.compile(
+    r"<entml:function_calls\b[^>]*>[\s\S]*?</entml:function_calls>",
+    re.IGNORECASE,
+)
+_ENTML_FUNCTION_CALLS_CLOSE = "</entml:function_calls>"
 
 
 class HistoryMarkupDetectionResult:
@@ -96,19 +105,25 @@ def _orphan_open_re(tag: str) -> re.Pattern[str]:
 
 
 def _split_entml_invoke_protected(segment: str) -> List[Tuple[str, bool]]:
-    """按 ``<entml:invoke>`` 切分；invoke 块（含未闭合尾部）不参与伪 history 剥离。"""
+    """按 ``<entml:function_calls>`` / ``<entml:invoke>`` 切分；保护区不参与伪 history 剥离。"""
     if not segment:
         return []
     parts: List[Tuple[str, bool]] = []
     i = 0
     while i < len(segment):
-        open_m = _ENTML_INVOKE_OPEN_RE.search(segment, i)
-        if not open_m:
+        fc_m = _ENTML_FUNCTION_CALLS_OPEN_RE.search(segment, i)
+        inv_m = _ENTML_INVOKE_OPEN_RE.search(segment, i)
+        candidates = [m for m in (fc_m, inv_m) if m]
+        if not candidates:
             parts.append((segment[i:], False))
             break
+        open_m = min(candidates, key=lambda m: m.start())
         if open_m.start() > i:
             parts.append((segment[i : open_m.start()], False))
-        block_m = _ENTML_INVOKE_BLOCK_RE.match(segment, open_m.start())
+        if open_m is fc_m:
+            block_m = _ENTML_FUNCTION_CALLS_BLOCK_RE.match(segment, open_m.start())
+        else:
+            block_m = _ENTML_INVOKE_BLOCK_RE.match(segment, open_m.start())
         if block_m:
             parts.append((block_m.group(0), True))
             i = block_m.end()
@@ -119,9 +134,9 @@ def _split_entml_invoke_protected(segment: str) -> List[Tuple[str, bool]]:
 
 
 def _open_before_entml_re(tag: str) -> re.Pattern[str]:
-    """``<tool>\\n…`` 未闭合但在 ``<entml:invoke`` 前 — 整段剥离。"""
+    """``<tool>\\n…`` 未闭合但在 ``<entml:(function_calls|invoke)`` 前 — 整段剥离。"""
     return re.compile(
-        rf"<{tag}\s*>\s*\n[\s\S]*?(?=<entml:invoke\b)",
+        rf"<{tag}\s*>\s*\n[\s\S]*?(?=<entml:(?:function_calls|invoke)\b)",
         re.IGNORECASE,
     )
 
@@ -250,8 +265,19 @@ def strip_fake_history_markup_for_display(content: str) -> Tuple[str, bool]:
     """流式 ``partial_text`` 用：完整块剥离 + 截断行尾未收齐的伪标签。"""
     cleaned, found = strip_fake_history_markup(content)
     invoke_m = _ENTML_INVOKE_OPEN_RE.search(cleaned)
-    if invoke_m and "</entml:invoke>" not in cleaned[invoke_m.start() :]:
-        return cleaned, found
+    fc_m = _ENTML_FUNCTION_CALLS_OPEN_RE.search(cleaned)
+    prot_m = None
+    if invoke_m and fc_m:
+        prot_m = invoke_m if invoke_m.start() <= fc_m.start() else fc_m
+    else:
+        prot_m = invoke_m or fc_m
+    if prot_m:
+        tail = cleaned[prot_m.start() :]
+        invoke_open = _ENTML_INVOKE_OPEN_RE.search(tail)
+        if invoke_open and "</entml:invoke>" not in tail[invoke_open.start() :]:
+            return cleaned, found
+        if _ENTML_FUNCTION_CALLS_OPEN_RE.search(tail) and _ENTML_FUNCTION_CALLS_CLOSE not in tail:
+            return cleaned, found
     tail = re.search(
         r"(?:^|\n)\s*(?:</?(?:assistant|tool)\b[^\n]*|</thinking>\s*(?:<(?:assistant|tool)\b[^\n]*)?)$",
         cleaned,

{echotools-2.3.70 → echotools-2.3.71}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.70 → echotools-2.3.71}/src/echotools.egg-info/SOURCES.txt

@@ -201,6 +201,7 @@ src/tests/test_events_event.py
 src/tests/test_facade.py
 src/tests/test_fake_history_markup_batch.py
 src/tests/test_fake_history_markup_invoke_preserve.py
+src/tests/test_fake_history_markup_reply_protect.py
 src/tests/test_fake_history_markup_stream.py
 src/tests/test_fault_thinking_close_batch.py
 src/tests/test_fault_thinking_close_stream.py

{echotools-2.3.70 → echotools-2.3.71}/src/tests/fixtures/simulated_fake_history_markup_responses.py

@@ -5,10 +5,10 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple
 
-from fixtures.simulated_llm_tool_responses import TOOLS, _TOOL_BY_NAME
+from fixtures.simulated_llm_tool_responses import _TOOL_BY_NAME, TOOLS
 
 READ_TOOL: Dict[str, Any] = {
     "type": "function",
@@ -400,6 +400,80 @@ FAKE_HISTORY_MARKUP_CASES: Tuple[HistoryMarkupCase, ...] = (
         expect_clean_excludes=("{Read: x}",),
         worst_split=True,
     ),
+    HistoryMarkupCase(
+        id="unclosed_fake_tool_invoke_trailing_reply",
+        description="未闭合伪 <tool> + invoke + 可见尾句：batch/stream 均须保留尾句",
+        extra_tools=("Read", "Edit"),
+        response=(
+            "前言\n"
+            "<tool>\n"
+            '{Edit: {"path": "a.py", "old_string": "x", "new_string": "y"}}\n'
+            f"{REAL_READ_INVOKE}\n"
+            "尾句保留。"
+        ),
+        expect_names=("Read",),
+        expect_args=({"path": "src/main.py"},),
+        expect_call_count=1,
+        expect_clean_contains=("前言", "尾句保留"),
+        expect_clean_excludes=("Edit", "<tool>"),
+        partial_leak_markers=("<tool>", "{Edit:", "entml:parameter"),
+        worst_split=True,
+    ),
+    HistoryMarkupCase(
+        id="function_calls_wrap_trailing_reply",
+        description="function_calls 包裹 invoke + 尾部可见回复",
+        extra_tools=("Read",),
+        response=(
+            "说明。\n"
+            "<entml:function_calls>\n"
+            f"{REAL_READ_INVOKE}\n"
+            "</entml:function_calls>\n"
+            "后续说明。"
+        ),
+        expect_names=("Read",),
+        expect_args=({"path": "src/main.py"},),
+        expect_call_count=1,
+        expect_clean_contains=("说明", "后续说明"),
+        expect_clean_excludes=("<tool>",),
+        partial_leak_markers=("<tool>", "{Edit:"),
+    ),
+    HistoryMarkupCase(
+        id="invoke_then_fake_tool_then_reply",
+        description="真实 invoke 后误写伪 tool，须剥离伪块保留尾句",
+        extra_tools=("Read", "Edit"),
+        response=(
+            f"{REAL_READ_INVOKE}\n"
+            "<tool>\n"
+            '{Edit: {"path": "a.py"}}\n'
+            "</tool>\n"
+            "尾句。"
+        ),
+        expect_names=("Read",),
+        expect_args=({"path": "src/main.py"},),
+        expect_call_count=1,
+        expect_clean_contains=("尾句",),
+        expect_clean_excludes=("Edit", "<tool>"),
+    ),
+    HistoryMarkupCase(
+        id="fake_tool_inside_function_calls_with_invoke",
+        description="伪 <tool> 块内含 function_calls+invoke，不得误删 invoke",
+        extra_tools=("Read", "Edit"),
+        response=(
+            "<tool>\n"
+            '{Edit: {"path": "a.py"}}\n'
+            "<entml:function_calls>\n"
+            f"{REAL_READ_INVOKE}\n"
+            "</entml:function_calls>\n"
+            "</tool>\n"
+            "尾句。"
+        ),
+        expect_names=("Read",),
+        expect_args=({"path": "src/main.py"},),
+        expect_call_count=1,
+        expect_clean_contains=("尾句",),
+        expect_clean_excludes=("Edit", "<tool>"),
+        worst_split=True,
+    ),
 )
 
 

echotools-2.3.71/src/tests/test_fake_history_markup_reply_protect.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+"""batch parse 与 stream finalize 对 invoke / 可见回复的保护须一致。"""
+
+import json
+from typing import Any, Dict, List
+
+import pytest
+from fixtures.simulated_fake_history_markup_responses import (
+    REAL_READ_INVOKE,
+    REAL_WEATHER_INVOKE,
+    HistoryMarkupCase,
+    iter_fake_history_markup_cases,
+    tools_for_markup_case,
+)
+
+from echotools.exec.fncall import get_protocol
+from echotools.exec.fncall.parsers.stream import FncallStreamParser
+from echotools.exec.fncall.shared.history_markup import strip_fake_history_markup
+
+INVOKE_REPLY_CASES = [
+    c
+    for c in iter_fake_history_markup_cases()
+    if c.expect_names
+    or c.id
+    in (
+        "unclosed_fake_tool_invoke_trailing_reply",
+        "function_calls_wrap_trailing_reply",
+        "invoke_then_fake_tool_then_reply",
+        "fake_tool_inside_function_calls_with_invoke",
+    )
+]
+
+EXTRA_CASES = (
+    HistoryMarkupCase(
+        id="visible_reply_before_and_after_invoke",
+        description="invoke 前后均有可见说明",
+        extra_tools=("Read",),
+        response=(
+            "开头说明。\n"
+            f"{REAL_READ_INVOKE}\n"
+            "结尾说明。"
+        ),
+        expect_names=("Read",),
+        expect_args=({"path": "src/main.py"},),
+        expect_call_count=1,
+        expect_clean_contains=("开头说明", "结尾说明"),
+        expect_clean_excludes=("<tool>",),
+        partial_leak_markers=("{Edit:", "\n<tool>\n"),
+    ),
+    HistoryMarkupCase(
+        id="thinking_visible_fake_invoke_reply",
+        description="thinking + 可见区伪块 + invoke + 尾句",
+        extra_tools=("Read", "Edit"),
+        response=(
+            "<entml:thinking>\nplan\n</entml:thinking>\n"
+            "中间说明\n"
+            "<tool>\n{Edit: x}\n</tool>\n"
+            f"{REAL_READ_INVOKE}\n"
+            "最终回复"
+        ),
+        expect_names=("Read",),
+        expect_args=({"path": "src/main.py"},),
+        expect_call_count=1,
+        expect_clean_contains=("中间说明", "最终回复"),
+        expect_clean_excludes=("Edit", "<tool>"),
+    ),
+    HistoryMarkupCase(
+        id="weather_after_unclosed_fake_tool",
+        description="未闭合伪 tool 后直接 weather invoke + 尾句",
+        response=(
+            "参考\n<tool>\n{get_weather: x}\n"
+            f"{REAL_WEATHER_INVOKE}\n"
+            "确认完毕。"
+        ),
+        expect_names=("get_weather",),
+        expect_args=({"city": "杭州", "unit": "c"},),
+        expect_call_count=1,
+        expect_clean_contains=("参考", "确认完毕"),
+        expect_clean_excludes=("{get_weather:", "<tool>"),
+        worst_split=True,
+    ),
+)
+
+ALL_CASES = INVOKE_REPLY_CASES + list(EXTRA_CASES)
+
+
+def _names(calls: List[Dict[str, Any]]) -> List[str]:
+    return [c["function"]["name"] for c in calls]
+
+
+def _args(calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    return [json.loads(c["function"]["arguments"]) for c in calls]
+
+
+def _batch(case: HistoryMarkupCase) -> tuple[str, List[Dict[str, Any]]]:
+    return get_protocol("entml").parse(case.response, tools_for_markup_case(case))
+
+
+def _stream(case: HistoryMarkupCase, chunk: int) -> tuple[str, List[Dict[str, Any]]]:
+    parser = FncallStreamParser(
+        protocol=get_protocol("entml"),
+        tools=tools_for_markup_case(case),
+    )
+    text = case.response
+    for i in range(0, len(text), chunk):
+        parser.feed(text[i : i + chunk])
+    return parser.finalize()
+
+
+def _assert_case(case: HistoryMarkupCase, clean: str, calls: List[Dict[str, Any]], label: str) -> None:
+    assert len(calls) == case.expect_call_count, f"{case.id}/{label}: call count"
+    if case.expect_names:
+        assert _names(calls) == list(case.expect_names), f"{case.id}/{label}: names"
+    if case.expect_args:
+        assert _args(calls) == list(case.expect_args), f"{case.id}/{label}: args"
+    for needle in case.expect_clean_contains:
+        assert needle in clean, f"{case.id}/{label}: missing {needle!r}"
+    for bad in case.expect_clean_excludes:
+        assert bad not in clean, f"{case.id}/{label}: leaked {bad!r}"
+    assert "entml:invoke" not in clean, f"{case.id}/{label}: invoke tag in clean"
+
+
+@pytest.mark.parametrize("case", ALL_CASES, ids=lambda c: c.id)
+def test_batch_stream_parity(case: HistoryMarkupCase) -> None:
+    batch_clean, batch_calls = _batch(case)
+    stream_clean, stream_calls = _stream(case, 3)
+    _assert_case(case, batch_clean, batch_calls, "batch")
+    _assert_case(case, stream_clean, stream_calls, "stream")
+    for needle in case.expect_clean_contains:
+        assert needle in batch_clean and needle in stream_clean, case.id
+
+
+@pytest.mark.parametrize("case", ALL_CASES, ids=lambda c: c.id)
+@pytest.mark.parametrize("chunk", [1, 8, 17, 64], ids=lambda n: f"c{n}")
+def test_stream_chunk_sizes(case: HistoryMarkupCase, chunk: int) -> None:
+    clean, calls = _stream(case, chunk)
+    _assert_case(case, clean, calls, f"c{chunk}")
+
+
+@pytest.mark.parametrize("case", ALL_CASES, ids=lambda c: c.id)
+def test_strip_preserves_invoke_and_reply(case: HistoryMarkupCase) -> None:
+    if not case.expect_names:
+        return
+    stripped, _ = strip_fake_history_markup(case.response)
+    assert "entml:invoke" in stripped, case.id
+    for needle in case.expect_clean_contains:
+        if needle not in ("说明", "参考历史", "我再确认一次"):
+            assert needle in stripped or needle in case.response, case.id
+
+
+def test_function_calls_partial_display() -> None:
+    partial = (
+        "说明。\n<tool>\n{Edit: x}\n"
+        "<entml:function_calls>\n"
+        '<entml:invoke name="Read">\n'
+        '<entml:parameter name="path">a.py'
+    )
+    from echotools.exec.fncall.shared.history_markup import (
+        strip_fake_history_markup_for_display,
+    )
+
+    display, _ = strip_fake_history_markup_for_display(partial)
+    assert "说明" in display
+    assert "<entml:invoke" in display
+    assert "entml:parameter" not in display or "<entml:invoke" in display