echotools 2.3.67__tar.gz → 2.3.71__tar.gz

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

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

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

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

{echotools-2.3.67 → echotools-2.3.71}/src/echotools/exec/fncall/prompt/inject.py

@@ -166,7 +166,9 @@ def inject_fncall(
                 sections.append(format_entml_current_user_message(current_user_message))
             # thinking 放在最后，超限截断时优先保留在 send_text 尾部
             thinking_section = build_entml_thinking_section(
-                protocol_options, has_tools=False
+                protocol_options,
+                has_tools=False,
+                history_text=history_text,
             )
             if thinking_section:
                 sections.append(thinking_section)

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

@@ -214,7 +214,7 @@ class EntmlProtocol(ToolProtocol):
 
         # thinking 放在最后，超限截断时优先保留在 send_text 尾部
         thinking_section = build_entml_thinking_section(
-            protocol_options, has_tools=bool(tool_descs)
+            protocol_options, has_tools=bool(tool_descs), history_text=history_text
         )
         if thinking_section:
             sections.append(thinking_section)
@@ -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.67 → echotools-2.3.71}/src/echotools/exec/fncall/protocols/entml_think/core.py

@@ -80,6 +80,16 @@ After completed tool turns appear in conversation history inside <tool> blocks (
 _THINKING_BEHAVIOR_AUTO_NO_TOOLS = """\
 You decide whether extended thinking helps for each reply. When the question has hidden complexity or when you are uncertain, open a <entml:thinking> block before continuing and strongly prefer to do so rather than guessing."""
 
+_THINKING_BEHAVIOR_OFF_WITH_HISTORY_WITH_TOOLS = """\
+Extended thinking is disabled for this reply. Do NOT output a <entml:thinking> block.
+
+Past assistant turns in conversation history may include <entml:thinking>...</entml:thinking> blocks for context only. Do not imitate or continue those blocks. Reply with visible text and/or <entml:invoke> tool call(s) directly."""
+
+_THINKING_BEHAVIOR_OFF_WITH_HISTORY_NO_TOOLS = """\
+Extended thinking is disabled for this reply. Do NOT output a <entml:thinking> block.
+
+Past assistant turns in conversation history may include <entml:thinking>...</entml:thinking> blocks for context only. Do not imitate or continue those blocks. Reply with visible text directly."""
+
 
 def normalize_thinking_level(level: Any) -> Optional[str]:
     """将 echotools 思考挡位归一化为 none | low | medium | high | xhigh | max | auto。"""
@@ -181,14 +191,34 @@ def _format_thinking_behavior(injection_mode: str, *, has_tools: bool) -> str:
     return f"<thinking_behavior>\n{body}\n</thinking_behavior>"
 
 
+def _format_forced_no_thinking_behavior(*, has_tools: bool) -> str:
+    body = (
+        _THINKING_BEHAVIOR_OFF_WITH_HISTORY_WITH_TOOLS
+        if has_tools
+        else _THINKING_BEHAVIOR_OFF_WITH_HISTORY_NO_TOOLS
+    )
+    return f"<thinking_behavior>\n{body}\n</thinking_behavior>"
+
+
 def build_entml_thinking_section(
     protocol_options: Optional[Dict[str, Any]] = None,
     *,
     has_tools: bool = True,
+    history_text: str = "",
 ) -> str:
-    """按思考挡位构建注入块：thinking_mode + max_thinking_length + thinking_behavior。"""
+    """按思考挡位构建注入块：thinking_mode + max_thinking_length + thinking_behavior。
+
+    思考关闭时：默认不注入；若 history 含 ``<entml:thinking>`` 则仅注入强制不思考的
+    ``<thinking_behavior>``（不含 ``<entml:thinking_mode>``）。
+    """
+    from echotools.exec.fncall.protocols.entml_think.hist import (
+        history_text_contains_entml_thinking,
+    )
+
     resolved = resolve_thinking_injection(protocol_options)
     if resolved is None:
+        if history_text_contains_entml_thinking(history_text):
+            return _format_forced_no_thinking_behavior(has_tools=has_tools)
         return ""
 
     injection_mode, max_length = resolved

{echotools-2.3.67 → echotools-2.3.71}/src/echotools/exec/fncall/protocols/entml_think/hist.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from typing import Any, Dict, List, Mapping, Optional
 
 REASONING_KEYS = ("reasoning", "reasoning_content", "reasoning_details")
@@ -13,6 +14,17 @@ _THINKING_BLOCK_TYPES = frozenset({"thinking", "reasoning", "redacted_thinking"}
 
 _THINKING_BLOCK_OPEN = "<entml:thinking>"
 _THINKING_BLOCK_CLOSE = "</entml:thinking>"
+_THINKING_OPEN_DETECT_RE = re.compile(
+    r"<entml:thinking\b",
+    re.IGNORECASE,
+)
+
+
+def history_text_contains_entml_thinking(history_text: str) -> bool:
+    """conversation_history 正文是否含 ``<entml:thinking>`` 历史思考块。"""
+    if not history_text or not history_text.strip():
+        return False
+    return _THINKING_OPEN_DETECT_RE.search(history_text) is not None
 
 
 def format_entml_thinking_history_block(text: str) -> str:

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

@@ -25,6 +25,23 @@ _PLAIN_THINKING_OPEN_LINE_RE = re.compile(
     r"(?:^|\n)\s*<thinking\s*>\s*(?:\n|$)",
     re.IGNORECASE | re.MULTILINE,
 )
+_ENTML_INVOKE_OPEN_RE = re.compile(
+    r"<entml:invoke\b",
+    re.IGNORECASE,
+)
+_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:
@@ -65,6 +82,14 @@ def _paired_block_re(tag: str) -> re.Pattern[str]:
     )
 
 
+def _paired_block_anywhere_re(tag: str) -> re.Pattern[str]:
+    """``<tool>\\n…\\n</tool>`` 即使前缀无换行（流式分片边界）也剥离。"""
+    return re.compile(
+        rf"<{tag}\s*>\s*\n[\s\S]*?\n\s*</{tag}\s*>",
+        re.IGNORECASE,
+    )
+
+
 def _orphan_close_re(tag: str) -> re.Pattern[str]:
     return re.compile(
         rf"(?:^|\n)([\s\S]*?)\n\s*</{tag}\s*>\s*(?:\n|$)",
@@ -79,19 +104,83 @@ def _orphan_open_re(tag: str) -> re.Pattern[str]:
     )
 
 
-def _strip_fake_blocks_in_segment(segment: str) -> Tuple[str, bool]:
+def _split_entml_invoke_protected(segment: str) -> List[Tuple[str, bool]]:
+    """按 ``<entml:function_calls>`` / ``<entml:invoke>`` 切分；保护区不参与伪 history 剥离。"""
+    if not segment:
+        return []
+    parts: List[Tuple[str, bool]] = []
+    i = 0
+    while i < len(segment):
+        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))
+        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()
+        else:
+            parts.append((segment[open_m.start() :], True))
+            break
+    return parts
+
+
+def _open_before_entml_re(tag: str) -> re.Pattern[str]:
+    """``<tool>\\n…`` 未闭合但在 ``<entml:(function_calls|invoke)`` 前 — 整段剥离。"""
+    return re.compile(
+        rf"<{tag}\s*>\s*\n[\s\S]*?(?=<entml:(?:function_calls|invoke)\b)",
+        re.IGNORECASE,
+    )
+
+
+def _orphan_open_to_eof_re(tag: str) -> re.Pattern[str]:
+    """未闭合伪块直到段末（下一段为 ``<entml:invoke>`` 时）。"""
+    return re.compile(
+        rf"<{tag}\s*>\s*\n[\s\S]*$",
+        re.IGNORECASE,
+    )
+
+
+def _strip_fake_blocks_in_unprotected(
+    segment: str,
+    *,
+    followed_by_invoke: bool = False,
+) -> Tuple[str, bool]:
     if not segment:
         return segment, False
     found = False
     text = segment
     for tag in _FAKE_HISTORY_TAGS:
-        pair_re = _paired_block_re(tag)
+        for pair_re in (_paired_block_re(tag), _paired_block_anywhere_re(tag)):
+            while True:
+                new_text, n = pair_re.subn("", text, count=1)
+                if n == 0:
+                    break
+                found = True
+                text = new_text
+        before_entml = _open_before_entml_re(tag)
         while True:
-            new_text, n = pair_re.subn("", text, count=1)
+            new_text, n = before_entml.subn("", text, count=1)
             if n == 0:
                 break
             found = True
             text = new_text
+        if followed_by_invoke:
+            to_eof = _orphan_open_to_eof_re(tag)
+            while True:
+                new_text, n = to_eof.subn("", text, count=1)
+                if n == 0:
+                    break
+                found = True
+                text = new_text
         close_re = _orphan_close_re(tag)
         while True:
             new_text, n = close_re.subn("\n", text, count=1)
@@ -117,6 +206,28 @@ def _strip_fake_blocks_in_segment(segment: str) -> Tuple[str, bool]:
     return text, found
 
 
+def _strip_fake_blocks_in_segment(segment: str) -> Tuple[str, bool]:
+    if not segment:
+        return segment, False
+    parts = _split_entml_invoke_protected(segment)
+    if len(parts) == 1 and parts[0][1]:
+        return segment, False
+    out: List[str] = []
+    found = False
+    for idx, (chunk, protected) in enumerate(parts):
+        if protected:
+            out.append(chunk)
+            continue
+        next_is_invoke = idx + 1 < len(parts) and parts[idx + 1][1]
+        cleaned, hit = _strip_fake_blocks_in_unprotected(
+            chunk,
+            followed_by_invoke=next_is_invoke,
+        )
+        out.append(cleaned)
+        found = found or hit
+    return "".join(out), found
+
+
 def strip_fake_history_markup(content: str) -> Tuple[str, bool]:
     """剥离块级伪 ``<assistant>`` / ``<tool>``；``<entml:thinking>`` 区域原样保留。"""
     if not content:
@@ -153,12 +264,35 @@ def strip_fake_history_markup(content: str) -> Tuple[str, bool]:
 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)
+    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*)$",
+        r"(?:^|\n)\s*(?:</?(?:assistant|tool)\b[^\n]*|</thinking>\s*(?:<(?:assistant|tool)\b[^\n]*)?)$",
         cleaned,
         re.IGNORECASE | re.MULTILINE,
     )
     if tail:
         cleaned = cleaned[: tail.start()]
         found = True
+    else:
+        glued = re.search(
+            r"</thinking>\s*<(?:assistant|tool)\b[^\n]*$",
+            cleaned,
+            re.IGNORECASE,
+        )
+        if glued:
+            cleaned = cleaned[: glued.start()]
+            found = True
     return cleaned, found

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

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

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

@@ -199,6 +199,10 @@ src/tests/test_errors_common.py
 src/tests/test_events.py
 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
 src/tests/test_fncall.py
@@ -227,5 +231,6 @@ src/tests/test_usage.py
 src/tests/test_web.py
 src/tests/test_web_broker.py
 src/tests/fixtures/__init__.py
+src/tests/fixtures/simulated_fake_history_markup_responses.py
 src/tests/fixtures/simulated_fault_thinking_responses.py
 src/tests/fixtures/simulated_llm_tool_responses.py