echotools 2.3.48__tar.gz → 2.3.50__tar.gz

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

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

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

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

{echotools-2.3.48 → echotools-2.3.50}/src/echotools/exec/fncall/parsers/stream.py

@@ -148,6 +148,23 @@ class FncallStreamParser:
             return fn(text)
         return text
 
+    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
+        if self._is_call_closed():
+            self._state = self.DONE
+
     def _feed_content_waiting(self, text: str) -> None:
         """thinking 已闭合后，对可见正文做 invoke 检测（不再经过 thinking 过滤器）。"""
         if not text:
@@ -173,11 +190,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,6 +200,8 @@ 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 状态下处理新块。"""
@@ -202,14 +217,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。
@@ -264,6 +282,10 @@ class FncallStreamParser:
         if self._state == self.WAITING_FOR_TAG:
             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

{echotools-2.3.48 → echotools-2.3.50}/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.48 → echotools-2.3.50}/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.48 → echotools-2.3.50}/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.48 → echotools-2.3.50}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -15,6 +15,7 @@ THINKING_BLOCK_RE = re.compile(
 
 _THINKING_OPEN_PREFIX = "<entml:thinking"
 _THINKING_CLOSE = "</entml:thinking>"
+_FAULT_THINKING_CLOSE = "</thinking>"
 # 与 thinking 共享 `<entml:` 前缀的其它标签：歧义 holdback 应交由工具流式状态机处理
 _AMBIGUOUS_ENTML_PREFIXES = (
     "<entml:invoke",
@@ -102,6 +103,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:
@@ -142,10 +162,13 @@ class EntmlThinkingStreamFilter:
         self._in_block = False
         # 当前 thinking 块是否已输出过任何内容（用于首片去前导空白）
         self._thinking_started = False
+        # 见到 ``</thinking>`` 后暂存，仅当后续出现 invoke 才视为闭合；否则当纯文本
+        self._fault_watch = False
+        self._fault_buffer = ""
 
     def in_open_thinking(self) -> bool:
-        """思考块已开始且尚未收到 </entml:thinking>（含开/闭标签分片 hold）。"""
-        if self._in_block:
+        """思考块已开始且尚未收到 ``</entml:thinking>``（含开/闭标签分片 hold）。"""
+        if self._in_block or self._fault_watch:
             return True
         open_at = self._pending.find(_THINKING_OPEN_PREFIX)
         if open_at >= 0:
@@ -157,47 +180,47 @@ class EntmlThinkingStreamFilter:
             return True
         return False
 
-    def _split_thinking_at_tool_markup(self, out: List[Tuple[str, str]]) -> bool:
-        """thinking 块内一旦出现工具 entml 前缀，立即切出为正文（含未收齐开标签）。"""
-        tool_at = find_ambiguous_entml_tool_prefix(self._pending)
-        if tool_at < 0:
+    def _try_resolve_fault_watch_on_invoke(self) -> bool:
+        """``</thinking>`` 之后若出现完整 invoke 开标签，则在该处结束 thinking。"""
+        if not self._fault_watch or not self._fault_buffer:
             return False
-        close_at = self._pending.find(_THINKING_CLOSE)
-        if close_at >= 0 and tool_at >= close_at:
+        invoke_at = find_complete_entml_invoke_open(self._fault_buffer)
+        if invoke_at < len(_FAULT_THINKING_CLOSE):
             return False
-        if tool_at > 0:
-            emitted = self._emit_thinking_piece(self._pending[:tool_at])
-            if emitted:
-                out.append(("thinking", emitted))
         self._in_block = False
+        self._fault_watch = False
         self._thinking_started = False
-        self._pending = self._pending[tool_at:]
+        self._pending = self._fault_buffer[len(_FAULT_THINKING_CLOSE) :]
+        self._fault_buffer = ""
         return True
 
-    def _split_thinking_at_invoke(self, out: List[Tuple[str, str]]) -> bool:
-        """thinking 未闭合但已出现完整 invoke 开标签时，提前结束 thinking 块。"""
-        invoke_at = find_complete_entml_invoke_open(self._pending)
-        if invoke_at < 0:
+    def _try_resolve_fault_watch_on_entml_close(self, out: List[Tuple[str, str]]) -> bool:
+        """未见 invoke 时出现 ``</entml:thinking>`` → ``</thinking>`` 仅为思考内纯文本。"""
+        if not self._fault_watch:
             return False
-        close_at = self._pending.find(_THINKING_CLOSE)
-        if close_at >= 0 and invoke_at >= close_at:
+        close_at = self._fault_buffer.find(_THINKING_CLOSE)
+        if close_at < 0:
             return False
-        if invoke_at > 0:
-            emitted = self._emit_thinking_piece(self._pending[:invoke_at])
-            if emitted:
-                out.append(("thinking", emitted))
+        emitted = self._emit_thinking_piece(self._fault_buffer[:close_at])
+        if emitted:
+            out.append(("thinking", emitted))
         self._in_block = False
+        self._fault_watch = False
         self._thinking_started = False
-        self._pending = self._pending[invoke_at:]
+        self._pending = self._fault_buffer[close_at + len(_THINKING_CLOSE) :]
+        self._fault_buffer = ""
         return True
 
-    def _feed_in_block(self, out: List[Tuple[str, str]]) -> bool:
-        """处理块内 pending；返回 False 表示应退出 feed 主循环。"""
-        if self._split_thinking_at_invoke(out):
+    def _feed_fault_watch(self, out: List[Tuple[str, str]]) -> bool:
+        """处理 ``</thinking>`` 容错观察期；返回 True 表示可继续主循环。"""
+        if self._try_resolve_fault_watch_on_invoke():
             return True
-        if self._split_thinking_at_tool_markup(out):
+        if self._try_resolve_fault_watch_on_entml_close(out):
             return True
+        return False
 
+    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]
@@ -205,10 +228,23 @@ class EntmlThinkingStreamFilter:
             if emitted:
                 out.append(("thinking", emitted))
             self._in_block = False
+            self._fault_watch = False
+            self._fault_buffer = ""
             self._thinking_started = False
             self._pending = self._pending[close_at + len(_THINKING_CLOSE) :]
             return True
 
+        fault_at = self._pending.find(_FAULT_THINKING_CLOSE)
+        if fault_at >= 0:
+            before = self._pending[:fault_at]
+            emitted = self._emit_thinking_piece(before)
+            if emitted:
+                out.append(("thinking", emitted))
+            self._fault_watch = True
+            self._fault_buffer = self._pending[fault_at:]
+            self._pending = ""
+            return False
+
         safe, tool_hold = _hold_ambiguous_tool_markup(self._pending)
         if tool_hold:
             if safe:
@@ -219,6 +255,8 @@ class EntmlThinkingStreamFilter:
             return False
 
         safe, hold = _hold_prefix(self._pending, _THINKING_CLOSE)
+        if not hold:
+            safe, hold = _hold_prefix(safe, _FAULT_THINKING_CLOSE)
         if safe:
             emitted = self._emit_thinking_piece(safe)
             if emitted:
@@ -257,6 +295,12 @@ class EntmlThinkingStreamFilter:
         out: List[Tuple[str, str]] = []
 
         while self._pending:
+            if self._fault_watch:
+                self._fault_buffer += self._pending
+                self._pending = ""
+                if self._feed_fault_watch(out):
+                    continue
+                break
             if self._in_block:
                 if not self._feed_in_block(out):
                     break
@@ -279,39 +323,37 @@ class EntmlThinkingStreamFilter:
 
     def finalize(self) -> List[Tuple[str, str]]:
         out: List[Tuple[str, str]] = []
+        if self._fault_watch:
+            if self._try_resolve_fault_watch_on_invoke():
+                pass
+            elif self._try_resolve_fault_watch_on_entml_close(out):
+                pass
+            else:
+                emitted = self._emit_thinking_piece(self._fault_buffer)
+                if emitted:
+                    out.append(("thinking", emitted))
+                self._fault_buffer = ""
+                self._fault_watch = False
+                self._in_block = False
+                self._thinking_started = False
         if self._in_block:
-            if not self._split_thinking_at_invoke(out):
-                if not self._split_thinking_at_tool_markup(out):
-                    # 未闭合且无工具 markup：剩余 pending 视作思考
-                    emitted = self._emit_thinking_piece(self._pending)
-                    if emitted:
-                        out.append(("thinking", emitted))
-                    self._pending = ""
-                    self._in_block = False
-                    self._thinking_started = False
-                    return out
-            # invoke 已切出，继续处理 _pending 中的正文
-            while self._pending:
-                if self._in_block:
-                    if not self._feed_in_block(out):
-                        break
-                    continue
-                if not self._feed_before_block(out):
-                    break
+            emitted = self._emit_thinking_piece(self._pending)
+            if emitted:
+                out.append(("thinking", emitted))
             self._pending = ""
             self._in_block = False
             self._thinking_started = False
-            return out
-        elif self._pending:
+        if self._pending:
             content, thinking = split_entml_thinking(self._pending)
             if thinking:
                 out.append(("thinking", thinking))
             if content:
                 out.append(("content", content))
             elif self._pending and not thinking:
-                # 仅 hold 了半截开标签：原样吐出，避免吞字
                 out.append(("content", self._pending))
         self._pending = ""
         self._in_block = False
+        self._fault_watch = False
+        self._fault_buffer = ""
         self._thinking_started = False
         return out

{echotools-2.3.48 → echotools-2.3.50}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.48 → echotools-2.3.50}/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

echotools-2.3.50/src/tests/test_entml_agent_output_formats.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+"""模型/agent 常见输出格式：正确 entml:invoke vs 错误 JSON/旧格式。"""
+
+import json
+
+import pytest
+
+from echotools.exec.fncall import get_protocol
+from echotools.exec.fncall.parsers.stream import FncallStreamParser
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "Read",
+            "description": "Read a file",
+            "parameters": {
+                "type": "object",
+                "properties": {"path": {"type": "string"}},
+                "required": ["path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_time",
+            "description": "Get current time",
+            "parameters": {"type": "object", "properties": {}, "required": []},
+        },
+    },
+]
+
+VALID_INVOKE = (
+    '<entml:invoke name="Read">\n'
+    '<entml:parameter name="path">C:/Users/Administrator/cursor_agent_simple.py</entml:parameter>\n'
+    "</entml:invoke>"
+)
+
+WRONG_JSON_TOOL = (
+    '{"name": "Read", "arguments": {"path": "C:/Users/Administrator/cursor_agent_simple.py"}}'
+)
+
+WRONG_TOOL_BLOCK = (
+    "<tool>\n"
+    '{"name": "Read", "arguments": {"path": "x.py"}}\n'
+    "</tool>"
+)
+
+FAKE_PARTIAL_JSON = '{"name": "Read", "arguments": {"path":'
+
+
+def _parse_batch(text: str):
+    proto = get_protocol("entml")
+    clean, calls = proto.parse(text, TOOLS)
+    return clean, calls
+
+
+def _parse_stream(text: str, *, chunk: int = 3):
+    proto = get_protocol("entml")
+    parser = FncallStreamParser(protocol=proto, tools=TOOLS)
+    for i in range(0, len(text), chunk):
+        parser.feed(text[i : i + chunk])
+    return parser.finalize()
+
+
+@pytest.mark.parametrize("chunk", [1, 4, 17])
+def test_valid_entml_invoke_batch_and_stream(chunk: int) -> None:
+    text = f"我先读文件。\n{VALID_INVOKE}\n完成。"
+    clean, calls = _parse_batch(text)
+    assert len(calls) == 1
+    assert calls[0]["function"]["name"] == "Read"
+    assert "cursor_agent_simple.py" in calls[0]["function"]["arguments"]
+    assert "entml:invoke" not in clean
+
+    clean_s, calls_s = _parse_stream(text, chunk=chunk)
+    assert len(calls_s) == 1
+    assert calls_s[0]["function"]["name"] == "Read"
+    assert "entml:invoke" not in clean_s
+
+
+def test_wrong_json_object_not_parsed_as_tool() -> None:
+    text = f"调用工具：\n{WRONG_JSON_TOOL}"
+    clean, calls = _parse_batch(text)
+    assert calls == []
+    assert "Read" in clean or "name" in clean
+
+
+def test_wrong_tool_block_not_parsed_as_entml_invoke() -> None:
+    text = f"回复\n{WRONG_TOOL_BLOCK}"
+    clean, calls = _parse_batch(text)
+    assert calls == []
+
+
+def test_truncated_json_not_parsed() -> None:
+    clean, calls = _parse_batch(FAKE_PARTIAL_JSON)
+    assert calls == []
+
+
+def test_thinking_then_valid_invoke(chunk: int = 5) -> None:
+    text = (
+        "<entml:thinking>\n需要先读脚本\n</entml:thinking>\n"
+        f"{VALID_INVOKE}"
+    )
+    clean, calls = _parse_stream(text, chunk=chunk)
+    assert len(calls) == 1
+    assert calls[0]["function"]["name"] == "Read"
+
+
+def test_fault_thinking_close_then_invoke() -> None:
+    text = (
+        "<entml:thinking>\nplan\n</thinking>\n"
+        '<entml:invoke name="get_time">\n'
+        "</entml:invoke>"
+    )
+    clean, calls = _parse_stream(text, chunk=2)
+    assert len(calls) == 1
+    assert calls[0]["function"]["name"] == "get_time"
+    assert json.loads(calls[0]["function"]["arguments"]) == {}
+
+
+def test_invoke_inside_unclosed_thinking_not_parsed() -> 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
+    clean, calls = parser.finalize()
+    assert calls == []
+
+
+def test_multiline_parameter_preserved() -> None:
+    body = "line1\nline2\nline3"
+    text = (
+        '<entml:invoke name="Read">\n'
+        f'<entml:parameter name="path">{body}</entml:parameter>\n'
+        "</entml:invoke>"
+    )
+    _, calls = _parse_batch(text)
+    args = json.loads(calls[0]["function"]["arguments"])
+    assert args["path"] == body