echotools 2.3.50__tar.gz → 2.3.51__tar.gz

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

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

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

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

{echotools-2.3.50 → 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,6 +165,9 @@ 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:
@@ -162,14 +182,47 @@ class FncallStreamParser:
         self._drain_thinking_holdback_to_fncall()
         self._detected = True
         self._state = self.IN_FUNCTION_CALLS
-        if self._is_call_closed():
-            self._state = self.DONE
+        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:
@@ -204,10 +257,24 @@ class FncallStreamParser:
             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)
@@ -279,29 +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:
-            if self._waiting_tail:
-                self._fncall_buf += self._normalize_stream_chunk(self._waiting_tail)
-                self._waiting_tail = ""
-            self._drain_thinking_holdback_to_fncall()
-            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,
@@ -326,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.50 → 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.50 → 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, ""
@@ -166,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:
@@ -219,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 = ""
@@ -234,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]
@@ -337,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.50 → echotools-2.3.51}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.50 → echotools-2.3.51}/src/tests/test_entml_agent_output_formats.py

@@ -120,15 +120,15 @@ def test_fault_thinking_close_then_invoke() -> None:
     assert json.loads(calls[0]["function"]["arguments"]) == {}
 
 
-def test_invoke_inside_unclosed_thinking_not_parsed() -> None:
+def test_invoke_inside_unclosed_thinking_parsed_when_complete() -> None:
     text = f"<entml:thinking>\nplan {VALID_INVOKE}\n"
     parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
     for i in range(0, len(text), 4):
         parser.feed(text[i : i + 4])
-    assert not parser.has_calls
-    assert "cursor_agent_simple.py" in parser.partial_thinking
+    assert parser.has_calls
     clean, calls = parser.finalize()
-    assert calls == []
+    assert len(calls) == 1
+    assert calls[0]["function"]["name"] == "Read"
 
 
 def test_multiline_parameter_preserved() -> None:

{echotools-2.3.50 → echotools-2.3.51}/src/tests/test_entml_parser_comprehensive.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import json
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
+from typing import Any, Dict, List, Optional, Sequence, Tuple
 
 import pytest
 
@@ -278,16 +278,18 @@ def _scenarios() -> List[ParserScenario]:
             id="invoke_inside_unclosed_thinking",
             text=f"<entml:thinking>\nplan\n{READ_INVOKE}\n",
             tools=[READ_TOOL],
-            expect_call_count=0,
-            expect_thinking_contains=("plan", "cursor_agent_simple.py"),
+            expect_names=("Read",),
+            expect_args=({"path": READ_PATH},),
+            expect_thinking_contains=("plan",),
             stream_only=True,
         ),
         ParserScenario(
             id="invoke_and_example_inside_closed_thinking",
             text=example_in_thinking,
             tools=[READ_TOOL],
-            expect_call_count=0,
-            expect_thinking_contains=("格式示例", "cursor_agent_simple.py"),
+            expect_names=("Read",),
+            expect_args=({"path": READ_PATH},),
+            expect_thinking_contains=("格式示例", "$FUNCTION_NAME"),
             stream_only=True,
         ),
         ParserScenario(
@@ -559,29 +561,27 @@ def test_invoke_index_inside_unclosed_thinking() -> None:
     assert not invoke_index_inside_unclosed_thinking(closed, pos3)
 
 
-def test_large_chunk_invoke_inside_unclosed_thinking_zero_calls() -> None:
-    """回归：首包很大且含 thinking 内 invoke 时不得进入 IN_FUNCTION_CALLS。"""
+def test_large_chunk_invoke_inside_unclosed_thinking_parsed() -> None:
+    """回归：首包很大且含 thinking 内完整 invoke 时应解析工具。"""
     text = f"<entml:thinking>\nplan\n{READ_INVOKE}\n"
     parser = FncallStreamParser(protocol=get_protocol("entml"), tools=[READ_TOOL])
     parser.feed(text[:64])
-    assert parser.state == FncallStreamParser.WAITING_FOR_TAG
     assert parser._thinking_filter is not None
-    assert parser._thinking_filter.in_open_thinking()
     parser.feed(text[64:])
     _, calls = parser.finalize()
-    assert calls == []
-    assert "cursor_agent_simple.py" in parser.partial_thinking
+    assert len(calls) == 1
+    assert calls[0]["function"]["name"] == "Read"
 
 
-def test_batch_thinking_invoke_known_gap() -> None:
-    """文档化：批量 parse 会解析 thinking 块内的 invoke（流式不会）。"""
+def test_batch_thinking_invoke_stream_parses_complete_inside() -> None:
+    """流式与批量均解析 thinking 内已闭合的真实 invoke。"""
     proto = get_protocol("entml")
     inside = f"<entml:thinking>\nplan\n{READ_INVOKE}\n</entml:thinking>\n"
     _, batch_calls = proto.parse(inside, [READ_TOOL])
     assert len(batch_calls) >= 1
     stream_clean, stream_calls, _ = _stream_parse(inside, [READ_TOOL], 8)
-    assert len(stream_calls) == 0
-    assert "entml:invoke" not in stream_clean
+    assert len(stream_calls) == 1
+    assert stream_calls[0]["function"]["name"] == "Read"
 
 
 def test_char_by_char_all_scenarios_with_tools() -> None:

{echotools-2.3.50 → echotools-2.3.51}/src/tests/test_fncall_stream_thinking.py

@@ -55,16 +55,16 @@ def test_split_entml_thinking_ignores_unclosed_block() -> None:
     assert INVOKE in content
 
 
-def test_invoke_inside_unclosed_thinking_not_parsed() -> None:
-    """未闭合 thinking 内的 entml 标签仅作思考文本，不解析为 tool call。"""
+def test_invoke_inside_unclosed_thinking_is_parsed_when_complete() -> None:
+    """thinking 内完整的真实 invoke 应切出并解析（占位符示例除外）。"""
     parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
     stream = f"<entml:thinking>\nplan {INVOKE}\n"
     for i in range(0, len(stream), 7):
         parser.feed(stream[i : i + 7])
-    assert not parser.has_calls
-    assert INVOKE in parser.partial_thinking or "entml:invoke" in parser.partial_thinking
+    assert parser.has_calls
     clean, calls = parser.finalize()
-    assert len(calls) == 0
+    assert len(calls) == 1
+    assert calls[0]["function"]["name"] == "get_weather"
 
 
 def test_invoke_after_thinking_close_is_parsed() -> None:
@@ -97,18 +97,18 @@ def test_no_thinking_invoke_still_works() -> None:
     assert "Sure" in clean
 
 
-def test_stream_thinking_invoke_inside_stays_thinking_until_close() -> None:
+def test_stream_thinking_invoke_inside_parsed_when_complete() -> None:
     parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
     parser.feed("<entml:thinking>\n")
     parser.feed("line one\n")
     assert "line one" in parser.partial_thinking
     assert not parser.has_calls
     parser.feed(f"mention {INVOKE}\n")
-    assert not parser.has_calls
-    assert "entml:invoke" in parser.partial_thinking
+    assert parser.has_calls
     parser.feed("</entml:thinking>\nanswer")
     clean, calls = parser.finalize()
-    assert len(calls) == 0
+    assert len(calls) == 1
+    assert calls[0]["function"]["name"] == "get_weather"
     assert "answer" in clean
 
 

{echotools-2.3.50 → echotools-2.3.51}/src/tests/test_stream_realtime_parse.py

@@ -112,7 +112,7 @@ def test_char_by_char_ready_matches_final_for_all_tool_cases() -> None:
         assert _args(incremental) == _args(final) == case.expect_args, case.id
 
 
-def test_unclosed_thinking_invoke_not_parsed_until_close() -> None:
+def test_unclosed_thinking_invoke_parsed_when_complete_inside() -> None:
     proto = get_protocol("entml")
     tools = TOOLS
     invoke = (
@@ -124,8 +124,8 @@ def test_unclosed_thinking_invoke_not_parsed_until_close() -> None:
     ready = []
     for ch in f"<entml:thinking>\nplan {invoke}\n":
         ready.extend(parser.feed(ch))
-    assert ready == []
-    for ch in f"</entml:thinking>\n可见\n{invoke}":
+    assert _names(ready) == ["get_weather"]
+    for ch in "</entml:thinking>\n可见":
         ready.extend(parser.feed(ch))
     ready.extend(parser.get_ready_tool_calls())
     _, final = parser.finalize()