echotools 2.3.49__tar.gz → 2.3.51__tar.gz

{echotools-2.3.49 → echotools-2.3.51}/PKG-INFO

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

{echotools-2.3.49 → echotools-2.3.51}/pyproject.toml

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

{echotools-2.3.49 → echotools-2.3.51}/src/echotools/exec/fncall/parsers/stream.py

@@ -139,8 +139,25 @@ class FncallStreamParser:
         return buffer, ""
 
     def _append_content_text(self, text: str) -> None:
-        if text:
-            self._text_parts.append(text)
+        if not text:
+            return
+        from echotools.exec.fncall.protocols.entml_think.parse import _THINKING_CLOSE
+
+        remainder = text
+        while True:
+            stripped = remainder.strip()
+            if not stripped:
+                return
+            if stripped == _THINKING_CLOSE:
+                return
+            if _THINKING_CLOSE in remainder:
+                before, _, after = remainder.partition(_THINKING_CLOSE)
+                if before.strip():
+                    self._text_parts.append(before)
+                remainder = after
+                continue
+            self._text_parts.append(remainder)
+            return
 
     def _normalize_stream_chunk(self, text: str) -> str:
         fn = getattr(self._protocol, "normalize_stream_buffer", None)
@@ -148,11 +165,64 @@ class FncallStreamParser:
             return fn(text)
         return text
 
+    def _invoke_close_tag(self) -> str:
+        return self._end_tags[0] if self._end_tags else "</entml:invoke>"
+
+    def _drain_thinking_holdback_to_fncall(self) -> None:
+        """invoke 已开始后，thinking 过滤器里对工具标签的 holdback 应并入 fncall 缓冲。"""
+        if self._thinking_filter is None:
+            return
+        pending = self._thinking_filter._pending
+        if pending:
+            self._fncall_buf += pending
+            self._thinking_filter._pending = ""
+
+    def _begin_function_calls(self, buffer_from: str, *, pos: int) -> None:
+        self._fncall_buf = buffer_from[pos:]
+        self._drain_thinking_holdback_to_fncall()
+        self._detected = True
+        self._state = self.IN_FUNCTION_CALLS
+        self._json_stream_encoder = None
+        if self._thinking_filter is not None:
+            self._thinking_filter.clear_invoke_handoff_state()
+
     def _feed_content_waiting(self, text: str) -> None:
         """thinking 已闭合后，对可见正文做 invoke 检测（不再经过 thinking 过滤器）。"""
         if not text:
             return
         text = self._normalize_stream_chunk(text)
+        if self._state == self.IN_FUNCTION_CALLS:
+            close_tag = self._invoke_close_tag()
+            if not self._is_call_closed():
+                if close_tag in text:
+                    idx = text.find(close_tag)
+                    self._fncall_buf += text[: idx + len(close_tag)]
+                    tail = text[idx + len(close_tag) :]
+                    if tail:
+                        self._feed_content_waiting(tail)
+                    return
+                self._fncall_buf += text
+                return
+            trigger_tags = self._protocol.get_trigger_tags()
+            found, pos = self._protocol.detect_start(text)
+            if found:
+                if pos > 0:
+                    self._append_content_text(text[:pos])
+                self._fncall_buf += text[pos:]
+                return
+            hold_from_fn = getattr(self._protocol, "find_fncall_hold_from", None)
+            if hold_from_fn is not None:
+                hold_from = hold_from_fn(text)
+                if hold_from is not None:
+                    if hold_from > 0:
+                        self._append_content_text(text[:hold_from])
+                    self._waiting_tail = text[hold_from:]
+                    return
+            safe, remain = self._split_safe_text(text, trigger_tags)
+            if safe:
+                self._append_content_text(safe)
+            self._waiting_tail = remain
+            return
         trigger_tags = self._protocol.get_trigger_tags()
         found, pos = self._protocol.detect_start(text)
         if not found:
@@ -173,11 +243,7 @@ class FncallStreamParser:
         if pos > 0:
             self._append_content_text(text[:pos])
 
-        self._fncall_buf = text[pos:]
-        self._detected = True
-        self._state = self.IN_FUNCTION_CALLS
-        if self._is_call_closed():
-            self._state = self.DONE
+        self._begin_function_calls(text, pos=pos)
 
     def _feed_waiting_thinking_plain(self, combined: str) -> None:
         """未闭合 thinking 阶段：块内一律按纯文本进 thinking，不检测 invoke。"""
@@ -187,12 +253,28 @@ class FncallStreamParser:
                 self._thinking_parts.append(part)
             elif part:
                 self._feed_content_waiting(part)
+        if self._state == self.IN_FUNCTION_CALLS:
+            self._drain_thinking_holdback_to_fncall()
 
     def _feed_waiting(self, chunk: str) -> None:
-        """在 WAITING_FOR_TAG 状态下处理新块。"""
+        """在 WAITING_FOR_TAG / IN_FUNCTION_CALLS 状态下处理新块。"""
         combined = self._normalize_stream_chunk(self._waiting_tail + chunk)
         self._waiting_tail = ""
 
+        if self._state == self.IN_FUNCTION_CALLS:
+            if self._thinking_filter is not None and self._thinking_filter.in_open_thinking():
+                self._feed_waiting_thinking_plain(combined)
+                return
+            if self._waiting_tail:
+                self._fncall_buf += self._normalize_stream_chunk(self._waiting_tail)
+                self._waiting_tail = ""
+            self._drain_thinking_holdback_to_fncall()
+            if not self._is_call_closed():
+                self._fncall_buf += combined
+                return
+            self._feed_content_waiting(combined)
+            return
+
         # 已进入 thinking 块时，块内不做 invoke 检测。
         if self._thinking_filter is not None and self._thinking_filter.in_open_thinking():
             self._feed_waiting_thinking_plain(combined)
@@ -202,14 +284,17 @@ class FncallStreamParser:
         found, pos = self._protocol.detect_start(combined)
 
         if found:
+            if self._thinking_filter is not None:
+                from echotools.exec.fncall.protocols.entml_think.parse import (
+                    invoke_index_inside_unclosed_thinking,
+                )
+                if invoke_index_inside_unclosed_thinking(combined, pos):
+                    self._feed_waiting_thinking_plain(combined)
+                    return
             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
+            self._begin_function_calls(combined, pos=pos)
             return
 
         # 无完整工具开标签时，再处理未闭合 thinking / 思考开标签 holdback。
@@ -261,25 +346,20 @@ class FncallStreamParser:
 
         self._raw_buf += chunk
 
-        if self._state == self.WAITING_FOR_TAG:
+        if self._state != self.DONE:
             self._feed_waiting(chunk)
-        else:
-            self._fncall_buf += self._normalize_stream_chunk(chunk)
-            if self._is_call_closed():
-                self._state = self.DONE
 
         self._pending_stream_delta = self._poll_streaming_tool_input_delta()
         ready = self.get_ready_tool_calls()
-        if ready:
-            if self._json_stream_encoder is not None:
-                self._json_stream_encoder.reset()
+        if ready and self._json_stream_encoder is not None:
+            self._json_stream_encoder.reset()
         return ready
 
     def _poll_streaming_tool_input_delta(self) -> Optional[Tuple[str, str]]:
         """invoke 开标签完整匹配后，返回 (tool_name, partial_json_delta)。"""
         if not self._detected or getattr(self._protocol, "id", None) != "entml":
             return None
-        if self._state not in (self.IN_FUNCTION_CALLS, self.DONE):
+        if self._state not in (self.IN_FUNCTION_CALLS,):
             return None
         from echotools.exec.fncall.protocols.entml_stream_json import (
             EntmlInvokeJsonStreamEncoder,
@@ -304,6 +384,43 @@ class FncallStreamParser:
         self._pending_stream_delta = None
         return delta
 
+    @property
+    def streaming_invoke_closed(self) -> bool:
+        """流式 fncall 缓冲中是否已出现 ``</entml:invoke>``。"""
+        if getattr(self._protocol, "id", None) != "entml":
+            return False
+        from echotools.exec.fncall.protocols.entml_stream_json import _INVOKE_CLOSE
+
+        return _INVOKE_CLOSE in self._fncall_buf
+
+    def complete_stream_delta_if_needed(self) -> Optional[Tuple[str, str]]:
+        """invoke 已开标签但未闭合时，补齐 partial_json 尾部的合法 JSON 后缀。"""
+        if not self._detected or getattr(self._protocol, "id", None) != "entml":
+            return None
+        if self.streaming_invoke_closed:
+            return None
+        from echotools.exec.fncall.protocols.entml_stream_json import (
+            _INVOKE_CLOSE,
+            EntmlInvokeJsonStreamEncoder,
+            build_streaming_json_snapshot,
+            split_invoke_open,
+        )
+
+        parsed = split_invoke_open(self._fncall_buf)
+        if not parsed:
+            return None
+        name, body_start = parsed
+        body = self._fncall_buf[body_start:]
+        snapshot = build_streaming_json_snapshot(body + _INVOKE_CLOSE)
+        if not snapshot:
+            return None
+        if self._json_stream_encoder is None:
+            self._json_stream_encoder = EntmlInvokeJsonStreamEncoder()
+        delta = self._json_stream_encoder.poll(body + _INVOKE_CLOSE)
+        if not delta:
+            return None
+        return (name, delta)
+
     def _assembly_for_tool_parse(self) -> str:
         """可供工具解析的已缓冲文本（不含 thinking 过滤器内部 pending）。"""
         return "".join(self._text_parts) + self._waiting_tail + self._fncall_buf

{echotools-2.3.49 → echotools-2.3.51}/src/echotools/exec/fncall/prompt/history.py

@@ -319,22 +319,3 @@ def _normalize_messages(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     return inject_orphan_tool_results(step2)
 
 
-# ---------------------------------------------------------------------------
-# 对话历史格式化
-# ---------------------------------------------------------------------------
-
-
-def _make_assistant_dedup_key(
-    content: Optional[str],
-    tool_calls: List[Dict[str, Any]],
-) -> Tuple[str, Tuple[Tuple[str, str], ...]]:
-    """生成 assistant 消息的去重键。"""
-    safe_content = content or ""
-    tc_key: Tuple[Tuple[str, str], ...] = tuple(
-        (
-            (tc.get("function") or {}).get("name") or "",
-            (tc.get("function") or {}).get("arguments") or "",
-        )
-        for tc in tool_calls
-    )
-    return (safe_content, tc_key)

{echotools-2.3.49 → echotools-2.3.51}/src/echotools/exec/fncall/prompt/history_format.py

@@ -41,7 +41,6 @@ def _append_assistant_part(
     index: int,
     protocol: Optional[Any],
     call_id_to_name: Dict[str, str],
-    seen_assistant_keys: set,
     *,
     include_thinking_in_history: bool,
 ) -> int:
@@ -55,7 +54,7 @@ def _append_assistant_part(
             tool_msgs.append(messages[j])
             j += 1
         blocks = format_assistant_block_with_results(
-            m, tool_msgs, protocol, call_id_to_name, seen_assistant_keys,
+            m, tool_msgs, protocol, call_id_to_name,
             include_thinking_in_history=include_thinking_in_history,
         )
         for block in blocks:
@@ -63,7 +62,7 @@ def _append_assistant_part(
         return j
 
     blocks = format_assistant_block(
-        m, content_str, protocol, call_id_to_name, seen_assistant_keys,
+        m, content_str, protocol, call_id_to_name,
         include_thinking_in_history=include_thinking_in_history,
     )
     for block in blocks:
@@ -81,7 +80,6 @@ def _format_conversation_history(
         return ""
 
     call_id_to_name: Dict[str, str] = {}
-    seen_assistant_keys = set()
     parts: List[Tuple[str, bool]] = []
     clean_fn = protocol.clean_tags if protocol and hasattr(protocol, "clean_tags") else None
 
@@ -98,7 +96,6 @@ def _format_conversation_history(
         if role == "assistant":
             i = _append_assistant_part(
                 parts, messages, i, protocol, call_id_to_name,
-                seen_assistant_keys,
                 include_thinking_in_history=include_thinking_in_history,
             )
             continue

{echotools-2.3.49 → echotools-2.3.51}/src/echotools/exec/fncall/prompt/prompt_helpers.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional, Set, Tuple
 
-from echotools.base.logger.manager import get_logger
 from echotools.exec.fncall.protocols.entml_think.hist import (
     extract_reasoning_text,
     format_entml_thinking_history_block,
@@ -12,15 +11,12 @@ from echotools.exec.fncall.shared.normalization import normalize_content
 from .history import (
     _TOOL_CALL_MARKER_RE,
     _convert_assistant_pseudo_calls,
-    _make_assistant_dedup_key,
     _render_inline_call_result,
     _render_tool_call,
     _render_tool_result,
     _try_convert_user_to_tool,
 )
 
-logger = get_logger(__name__)
-
 
 def _assistant_history_content_blocks(
     m: Dict[str, Any],
@@ -139,19 +135,12 @@ def format_assistant_block(
     content_str: str,
     protocol: Optional[Any],
     call_id_to_name: Dict[str, str],
-    seen_assistant_keys: Set[Tuple[str, Tuple[Tuple[str, str], ...]]],
     *,
     include_thinking_in_history: bool = False,
 ) -> List[str]:
     tcs: List[Dict[str, Any]] = m.get("tool_calls") or []
     _register_tool_call_names(tcs, call_id_to_name)
 
-    dedup_key = _make_assistant_dedup_key(content_str, tcs)
-    if dedup_key in seen_assistant_keys:
-        logger.debug("跳过重复 assistant 消息（dedup_key 已见）")
-        return []
-    seen_assistant_keys.add(dedup_key)
-
     parts: List[str] = []
     assistant = _format_assistant_text_block(
         m, content_str, protocol, include_thinking_in_history=include_thinking_in_history
@@ -174,7 +163,6 @@ def format_assistant_block_with_results(
     tool_msgs: List[Dict[str, Any]],
     protocol: Optional[Any],
     call_id_to_name: Dict[str, str],
-    seen_assistant_keys: Set[Tuple[str, Tuple[Tuple[str, str], ...]]],
     *,
     include_thinking_in_history: bool = False,
 ) -> List[str]:
@@ -182,12 +170,6 @@ def format_assistant_block_with_results(
     content_str = normalize_content(m.get("content", ""))
     _register_tool_call_names(tcs, call_id_to_name)
 
-    dedup_key = _make_assistant_dedup_key(content_str, tcs)
-    if dedup_key in seen_assistant_keys:
-        logger.debug("跳过重复 assistant 消息（dedup_key 已见）")
-        return []
-    seen_assistant_keys.add(dedup_key)
-
     parts: List[str] = []
     assistant = _format_assistant_text_block(
         m, content_str, protocol, include_thinking_in_history=include_thinking_in_history

{echotools-2.3.49 → echotools-2.3.51}/src/echotools/exec/fncall/protocols/entml_think/core.py

@@ -65,7 +65,7 @@ _LEGACY_ON_DEFAULT_MAX = _DEFAULT_MAX_BY_LEVEL["medium"]
 _THINKING_BEHAVIOR_ON_WITH_TOOLS = """\
 Your default is to think before it answers to give the person the best possible answer. Even for questions that might seem obvious, if there are any signs of lurking complexity, You takes the time to open up an extended thinking block and dig in to make sure it's got the details figured out and isn't just pattern-matching to the familiar. At the end of its thinking, You restates which language it should respond in.
 
-You MUST output a <entml:thinking> block before any other content in every reply. Only after that block, output your visible reply and/or <entml:invoke> tool call(s). Never skip the thinking block."""
+You MUST output a <entml:thinking> block before any other content in every reply. Only after that block closes with </entml:thinking>, output your visible reply and/or <entml:invoke> tool call(s). Never place <entml:invoke> inside <entml:thinking>. Never skip the thinking block."""
 
 _THINKING_BEHAVIOR_ON_NO_TOOLS = """\
 Your default is to think before it answers to give the person the best possible answer. Even for questions that might seem obvious, if there are any signs of lurking complexity, You takes the time to open up an extended thinking block and dig in to make sure it's got the details figured out and isn't just pattern-matching to the familiar. At the end of its thinking, You restates which language it should respond in.

{echotools-2.3.49 → echotools-2.3.51}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import re
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from echotools.exec.fncall.protocols.entml_patterns import (
+    BLOCK_RE,
     extract_attr_value,
     normalize_entml_name,
 )
@@ -26,6 +27,62 @@ _AMBIGUOUS_ENTML_PREFIXES = (
 _INVOKE_PREFIX = "<entml:invoke"
 
 
+def _is_placeholder_invoke_name(name: str) -> bool:
+    """提示词占位符（如 ``$FUNCTION_NAME``）不算真实工具调用。"""
+    n = (name or "").strip()
+    return not n or "$" in n
+
+
+def _invoke_name_from_block(block: str) -> Optional[str]:
+    prefix_len = len(_INVOKE_PREFIX)
+    pos = block.find(_INVOKE_PREFIX)
+    if pos < 0:
+        return None
+    gt = block.find(">", pos + prefix_len)
+    if gt < 0:
+        return None
+    attrs = block[pos + prefix_len : gt]
+    name = extract_attr_value(attrs, "name")
+    if not name:
+        return None
+    return normalize_entml_name(name)
+
+
+def find_actionable_invoke_block(buffer: str) -> Optional[Tuple[str, str, str]]:
+    """返回首个非占位符的完整 invoke 块：``(before, block, after)``。"""
+    if not buffer:
+        return None
+    for match in BLOCK_RE.finditer(buffer):
+        block = match.group(0)
+        name = _invoke_name_from_block(block)
+        if not name or _is_placeholder_invoke_name(name):
+            continue
+        return buffer[: match.start()], block, buffer[match.end() :]
+    return None
+
+
+def find_actionable_invoke_open(buffer: str) -> int:
+    """返回首个非占位符且已闭合 ``>`` 的 invoke 开标签下标；否则 -1。"""
+    if not buffer:
+        return -1
+    search_from = 0
+    prefix_len = len(_INVOKE_PREFIX)
+    while True:
+        pos = buffer.find(_INVOKE_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:
+            name = normalize_entml_name(name)
+        if name and not _is_placeholder_invoke_name(name):
+            return pos
+        search_from = close + 1
+
+
 def find_complete_entml_invoke_open(buffer: str) -> int:
     """返回首个含 name 且已闭合 ``>`` 的 ``<entml:invoke`` 起始下标；否则 -1。"""
     if not buffer:
@@ -59,9 +116,12 @@ def find_ambiguous_entml_tool_prefix(buffer: str) -> int:
 
 
 def _hold_ambiguous_tool_markup(buffer: str) -> Tuple[str, str]:
-    """thinking 块内：尾部是工具 entml 标签真前缀时 hold，避免误当 thinking 吐出。"""
+    """thinking 块内：从最早工具 entml 前缀处 hold，避免 invoke 被当作 thinking 吐出。"""
     if not buffer:
         return "", ""
+    ambig = find_ambiguous_entml_tool_prefix(buffer)
+    if ambig >= 0:
+        return buffer[:ambig], buffer[ambig:]
     lt = buffer.rfind("<")
     if lt < 0:
         return buffer, ""
@@ -103,6 +163,25 @@ def has_unclosed_entml_thinking(text: str) -> bool:
     return False
 
 
+def invoke_index_inside_unclosed_thinking(text: str, invoke_at: int) -> bool:
+    """``invoke_at`` 是否落在尚未正式 ``</entml:thinking>`` 闭合的块内。
+
+    已出现容错 ``</thinking>`` 且 invoke 在其后的段落，视为 thinking 外。
+    """
+    if invoke_at < 0:
+        return False
+    think_open = text.find(_THINKING_OPEN_PREFIX)
+    if think_open < 0 or invoke_at <= think_open:
+        return False
+    entml_close = text.find(_THINKING_CLOSE, think_open)
+    if entml_close >= 0:
+        return invoke_at < entml_close
+    fault_at = text.find(_FAULT_THINKING_CLOSE, think_open)
+    if fault_at >= 0:
+        return invoke_at < fault_at + len(_FAULT_THINKING_CLOSE)
+    return True
+
+
 def split_entml_thinking(text: str) -> Tuple[str, str]:
     """从文本中剥离 <entml:thinking> 块，返回 (正文, 思考链拼接)。"""
     if not text:
@@ -147,6 +226,13 @@ class EntmlThinkingStreamFilter:
         self._fault_watch = False
         self._fault_buffer = ""
 
+    def clear_invoke_handoff_state(self) -> None:
+        """invoke 已交给正文/工具解析后，结束 thinking / fault 观察状态。"""
+        self._in_block = False
+        self._fault_watch = False
+        self._fault_buffer = ""
+        self._thinking_started = False
+
     def in_open_thinking(self) -> bool:
         """思考块已开始且尚未收到 ``</entml:thinking>``（含开/闭标签分片 hold）。"""
         if self._in_block or self._fault_watch:
@@ -200,14 +286,56 @@ class EntmlThinkingStreamFilter:
             return True
         return False
 
+    def _try_emit_actionable_invoke_from_in_block(
+        self, out: List[Tuple[str, str]]
+    ) -> bool:
+        """thinking 块内出现真实 invoke 时，在该处结束 thinking 并交给正文解析。"""
+        split = find_actionable_invoke_block(self._pending)
+        if split is not None:
+            before, invoke_block, after = split
+            if before:
+                emitted = self._emit_thinking_piece(before)
+                if emitted:
+                    out.append(("thinking", emitted))
+            out.append(("content", invoke_block))
+            self._in_block = False
+            self._fault_watch = False
+            self._fault_buffer = ""
+            self._thinking_started = False
+            rest = after.lstrip()
+            if rest.startswith(_THINKING_CLOSE):
+                rest = rest[len(_THINKING_CLOSE) :].lstrip()
+            self._pending = rest
+            return True
+        return False
+
+    def _emit_piece_with_actionable_invokes(
+        self, piece: str, out: List[Tuple[str, str]]
+    ) -> str:
+        """从 thinking 正文中切出真实 invoke 块，返回剩余 thinking 文本。"""
+        while piece:
+            split = find_actionable_invoke_block(piece)
+            if split is None:
+                break
+            before, invoke_block, rest = split
+            if before:
+                emitted = self._emit_thinking_piece(before)
+                if emitted:
+                    out.append(("thinking", emitted))
+            out.append(("content", invoke_block))
+            piece = rest
+        return piece
+
     def _feed_in_block(self, out: List[Tuple[str, str]]) -> bool:
         """处理块内 pending；返回 False 表示应退出 feed 主循环。"""
         close_at = self._pending.find(_THINKING_CLOSE)
         if close_at >= 0:
             piece = self._pending[:close_at]
-            emitted = self._emit_thinking_piece(piece)
-            if emitted:
-                out.append(("thinking", emitted))
+            piece = self._emit_piece_with_actionable_invokes(piece, out)
+            if piece:
+                emitted = self._emit_thinking_piece(piece)
+                if emitted:
+                    out.append(("thinking", emitted))
             self._in_block = False
             self._fault_watch = False
             self._fault_buffer = ""
@@ -215,6 +343,9 @@ class EntmlThinkingStreamFilter:
             self._pending = self._pending[close_at + len(_THINKING_CLOSE) :]
             return True
 
+        if self._try_emit_actionable_invoke_from_in_block(out):
+            return True
+
         fault_at = self._pending.find(_FAULT_THINKING_CLOSE)
         if fault_at >= 0:
             before = self._pending[:fault_at]
@@ -318,10 +449,11 @@ class EntmlThinkingStreamFilter:
                 self._in_block = False
                 self._thinking_started = False
         if self._in_block:
-            emitted = self._emit_thinking_piece(self._pending)
-            if emitted:
-                out.append(("thinking", emitted))
-            self._pending = ""
+            if not self._try_emit_actionable_invoke_from_in_block(out):
+                emitted = self._emit_thinking_piece(self._pending)
+                if emitted:
+                    out.append(("thinking", emitted))
+                self._pending = ""
             self._in_block = False
             self._thinking_started = False
         if self._pending:

{echotools-2.3.49 → echotools-2.3.51}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.49 → echotools-2.3.51}/src/echotools.egg-info/SOURCES.txt

@@ -182,7 +182,9 @@ src/tests/test_coverage_core.py
 src/tests/test_dispatch.py
 src/tests/test_dispatch_extended.py
 src/tests/test_dispatch_race.py
+src/tests/test_entml_agent_output_formats.py
 src/tests/test_entml_bare_invoke_format.py
+src/tests/test_entml_parser_comprehensive.py
 src/tests/test_entml_protocol.py
 src/tests/test_entml_stream_json.py
 src/tests/test_entml_stream_json_exhaustive.py