echotools 2.3.40__tar.gz → 2.3.42__tar.gz

{echotools-2.3.40 → echotools-2.3.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.3.40
+Version: 2.3.42
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Author: nichengfuben
 License: MIT

{echotools-2.3.40 → echotools-2.3.42}/pyproject.toml

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

{echotools-2.3.40 → echotools-2.3.42}/src/echotools/exec/fncall/parsers/stream.py

@@ -13,7 +13,7 @@ from echotools.exec.protocol.base import ToolProtocol
 # 懒导入：仅 entml 协议需要
 def _make_thinking_filter(protocol: ToolProtocol):
     if getattr(protocol, "id", None) == "entml":
-        from echotools.exec.fncall.protocols.entml_thinking_parse import (
+        from echotools.exec.fncall.protocols.entml_think.parse import (
             EntmlThinkingStreamFilter,
         )
         return EntmlThinkingStreamFilter()
@@ -177,7 +177,7 @@ class FncallStreamParser:
         self._waiting_tail = ""
 
         if self._thinking_filter is not None:
-            from echotools.exec.fncall.protocols.entml_thinking_parse import (
+            from echotools.exec.fncall.protocols.entml_think.parse import (
                 has_unclosed_entml_thinking,
             )
             if (
@@ -262,7 +262,7 @@ class FncallStreamParser:
 
         # 兜底：剥离残留 <entml:thinking>（holdback 边界/分片异常时）
         if self._thinking_filter is not None and clean_text:
-            from echotools.exec.fncall.protocols.entml_thinking_parse import (
+            from echotools.exec.fncall.protocols.entml_think.parse import (
                 split_entml_thinking,
             )
             clean_text, more_thinking = split_entml_thinking(clean_text)

{echotools-2.3.40 → echotools-2.3.42}/src/echotools/exec/fncall/prompt/history.py

@@ -39,6 +39,45 @@ _TOOL_CALL_MARKER_RE = re.compile(
     re.MULTILINE,
 )
 
+# entml 标签清理正则
+_ENTML_FNCALL_BLOCK_RE = re.compile(
+    r"<entml:function_calls\b[^>]*>.*?</entml:function_calls>",
+    re.DOTALL,
+)
+_ENTML_INVOKE_RE = re.compile(
+    r'<entml:invoke\s+name="[^"]+"\s*>.*?</entml:invoke>',
+    re.DOTALL,
+)
+_ENTML_PARAMETERS_RE = re.compile(
+    r'<entml:parameters>.*?</entml:parameters>',
+    re.DOTALL,
+)
+_ENTML_PARAM_RE = re.compile(
+    r'<entml:parameter\s+name="[^"]+"[^>]*>.*?</entml:parameter>',
+    re.DOTALL,
+)
+# 清理任意 entml:* 标签
+_ENTML_ANY_TAG_RE = re.compile(
+    r'<entml:[a-zA-Z_][\w]*\b[^>]*>.*?</entml:[a-zA-Z_][\w]*>',
+    re.DOTALL,
+)
+
+
+def _clean_entml_tags(content: str) -> str:
+    """移除内容中的所有 entml 标签及其内部内容。"""
+    if not content:
+        return content
+    cleaned = content
+    cleaned = _ENTML_FNCALL_BLOCK_RE.sub("", cleaned)
+    cleaned = _ENTML_INVOKE_RE.sub("", cleaned)
+    cleaned = _ENTML_PARAMETERS_RE.sub("", cleaned)
+    cleaned = _ENTML_PARAM_RE.sub("", cleaned)
+    cleaned = _ENTML_ANY_TAG_RE.sub("", cleaned)
+    # 清理多余空行
+    lines = [line for line in cleaned.splitlines() if line.strip()]
+    return "\n".join(lines)
+
+
 # ---------------------------------------------------------------------------
 # 渲染工具调用 / 工具结果
 # ---------------------------------------------------------------------------

echotools-2.3.42/src/echotools/exec/fncall/prompt/history_format.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+"""Conversation history block formatting."""
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from echotools.exec.fncall.shared.normalization import normalize_content
+
+from .prompt_helpers import (
+    format_assistant_block,
+    format_assistant_block_with_results,
+    format_tool_block,
+    format_user_block,
+    join_history_parts,
+)
+
+
+def history_contains_tool_calls(messages: List[Dict[str, Any]]) -> bool:
+    """历史消息中是否包含 assistant tool_calls 或 tool 结果。"""
+    for m in messages:
+        role = m.get("role") or "user"
+        if role == "assistant" and m.get("tool_calls"):
+            return True
+        if role == "tool":
+            return True
+    return False
+
+
+def _append_user_part(
+    parts: List[Tuple[str, bool]],
+    m: Dict[str, Any],
+    clean_fn: Any,
+) -> None:
+    content_str = normalize_content(m.get("content", ""))
+    parts.append((format_user_block(content_str, clean_fn), False))
+
+
+def _append_assistant_part(
+    parts: List[Tuple[str, bool]],
+    messages: List[Dict[str, Any]],
+    index: int,
+    protocol: Optional[Any],
+    call_id_to_name: Dict[str, str],
+    seen_assistant_keys: set,
+    *,
+    include_thinking_in_history: bool,
+) -> int:
+    m = messages[index]
+    content_str = normalize_content(m.get("content", ""))
+    tcs = m.get("tool_calls") or []
+    if tcs:
+        tool_msgs = []
+        j = index + 1
+        while j < len(messages) and (messages[j].get("role") or "user") == "tool":
+            tool_msgs.append(messages[j])
+            j += 1
+        blocks = format_assistant_block_with_results(
+            m, tool_msgs, protocol, call_id_to_name, seen_assistant_keys,
+            include_thinking_in_history=include_thinking_in_history,
+        )
+        for block in blocks:
+            parts.append((block, False))
+        return j
+
+    blocks = format_assistant_block(
+        m, content_str, protocol, call_id_to_name, seen_assistant_keys,
+        include_thinking_in_history=include_thinking_in_history,
+    )
+    for block in blocks:
+        parts.append((block, False))
+    return index + 1
+
+
+def _format_conversation_history(
+    messages: List[Dict[str, Any]],
+    protocol: Optional[Any] = None,
+    *,
+    include_thinking_in_history: bool = False,
+) -> str:
+    if not messages:
+        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
+
+    i = 0
+    while i < len(messages):
+        m = messages[i]
+        role: str = m.get("role") or "user"
+
+        if role == "user":
+            _append_user_part(parts, m, clean_fn)
+            i += 1
+            continue
+
+        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
+
+        if role == "tool":
+            content_str = normalize_content(m.get("content", ""))
+            parts.append((format_tool_block(m, content_str, call_id_to_name), True))
+            i += 1
+            continue
+
+        content_str = normalize_content(m.get("content", ""))
+        parts.append((f"<{role}>\n{content_str}\n</{role}>", False))
+        i += 1
+
+    return join_history_parts(parts)

{echotools-2.3.40 → echotools-2.3.42}/src/echotools/exec/fncall/prompt/inject.py

@@ -22,8 +22,8 @@ from echotools.exec.fncall.protocols.entml import (
     format_entml_conversation_history,
     format_entml_current_user_message,
 )
-from echotools.exec.fncall.protocols.entml_thinking import build_entml_thinking_section
-from echotools.exec.fncall.protocols.entml_thinking_history import (
+from echotools.exec.fncall.protocols.entml_think.core import build_entml_thinking_section
+from echotools.exec.fncall.protocols.entml_think.hist import (
     apply_thinking_history_policy,
     parse_include_thinking_in_history,
 )
@@ -145,12 +145,13 @@ def inject_fncall(
     if not tools:
         if protocol.id == "entml":
             sections: List[str] = []
-            thinking_section = build_entml_thinking_section(protocol_options)
-            if thinking_section:
-                sections.append(thinking_section)
             if history_text.strip():
                 sections.append(format_entml_conversation_history(history_text))
             sections.append(format_entml_current_user_message(current_user_message))
+            # thinking 放在最后，超限截断时优先保留在 send_text 尾部
+            thinking_section = build_entml_thinking_section(protocol_options)
+            if thinking_section:
+                sections.append(thinking_section)
             prompt = "\n\n".join(sections)
         else:
             prompt = build_no_tools_prompt(history_text, current_user_message)

{echotools-2.3.40 → echotools-2.3.42}/src/echotools/exec/fncall/prompt/prompt_helpers.py

@@ -3,7 +3,7 @@ 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_thinking_history import (
+from echotools.exec.fncall.protocols.entml_think.hist import (
     extract_reasoning_text,
     format_entml_thinking_history_block,
 )

{echotools-2.3.40 → echotools-2.3.42}/src/echotools/exec/fncall/protocols/entml.py

@@ -8,6 +8,7 @@
 from __future__ import annotations
 
 import json as _json
+import re
 from typing import Any, Dict, List, Optional, Tuple
 
 from echotools.exec.fncall.prompt.templates import (
@@ -18,8 +19,7 @@ from echotools.exec.fncall.protocols.entml_invoke import (
     parse_entml_tool_calls,
 )
 from echotools.exec.fncall.protocols.entml_patterns import BLOCK_RE
-from echotools.exec.fncall.protocols.entml_sanitize import strip_entml_from_content
-from echotools.exec.fncall.protocols.entml_thinking import build_entml_thinking_section
+from echotools.exec.fncall.protocols.entml_think.core import build_entml_thinking_section
 from echotools.exec.fncall.protocols.entml_tools import format_entml_tool_descs
 from echotools.exec.fncall.shared.coercion import _build_param_schema_index
 from echotools.exec.fncall.shared.normalization import (
@@ -28,6 +28,27 @@ from echotools.exec.fncall.shared.normalization import (
 )
 from echotools.exec.protocol.base import ToolProtocol
 
+# 仅按 entml: 前缀剥离标签，不区分具体标签名。
+_ENTML_PAIR_RE = re.compile(
+    r"<entml:[a-zA-Z_][\w]*\b[^>]*>.*?</entml:[a-zA-Z_][\w]*>",
+    re.DOTALL,
+)
+_ENTML_SELF_CLOSING_RE = re.compile(r"<entml:[a-zA-Z_][\w]*\b[^>]*/>", re.DOTALL)
+_ENTML_ORPHAN_CLOSE_RE = re.compile(r"</entml:[a-zA-Z_][\w]*>", re.DOTALL)
+_ENTML_ORPHAN_OPEN_RE = re.compile(r"<entml:[a-zA-Z_][\w]*\b[^>]*>", re.DOTALL)
+
+
+def strip_entml_from_content(content: str) -> str:
+    """从 user 消息正文剥离所有 entml:* 标签及残留开闭标签。"""
+    if not content:
+        return content
+    cleaned = content
+    cleaned = _ENTML_PAIR_RE.sub("", cleaned)
+    cleaned = _ENTML_SELF_CLOSING_RE.sub("", cleaned)
+    cleaned = _ENTML_ORPHAN_CLOSE_RE.sub("", cleaned)
+    cleaned = _ENTML_ORPHAN_OPEN_RE.sub("", cleaned)
+    return cleaned.strip()
+
 
 def _parse_tool_call_args(tc: Dict[str, Any]) -> tuple[str, Dict[str, Any]]:
     fn = tc.get("function") or {}
@@ -141,10 +162,6 @@ class EntmlProtocol(ToolProtocol):
         else:
             sections = [_ENTML_INSTRUCTION.rstrip()]
 
-        thinking_section = build_entml_thinking_section(protocol_options)
-        if thinking_section:
-            sections.append(thinking_section)
-
         if user_system_prompt and user_system_prompt.strip():
             sections.append(
                 f"<user_system_prompt>\n{user_system_prompt.strip()}\n</user_system_prompt>"
@@ -161,6 +178,12 @@ class EntmlProtocol(ToolProtocol):
             sections.append(f"<loop_warning>\n{loop_warning}\n</loop_warning>")
 
         sections.append(format_entml_current_user_message(current_user_message))
+
+        # thinking 放在最后，超限截断时优先保留在 send_text 尾部
+        thinking_section = build_entml_thinking_section(protocol_options)
+        if thinking_section:
+            sections.append(thinking_section)
+
         return "\n\n".join(sections)
 
     def detect_start(self, buffer: str) -> Tuple[bool, int]:

echotools-2.3.42/src/echotools/exec/fncall/protocols/entml_think/__init__.py

@@ -0,0 +1,31 @@
+"""Entml thinking: prompt section, history blocks, stream parsing."""
+
+from echotools.exec.fncall.protocols.entml_think.core import (
+    build_entml_thinking_section,
+    parse_max_thinking_length,
+)
+from echotools.exec.fncall.protocols.entml_think.hist import (
+    apply_thinking_history_policy,
+    extract_reasoning_text,
+    format_entml_thinking_history_block,
+    parse_include_thinking_in_history,
+    parse_interleaved_history,
+)
+from echotools.exec.fncall.protocols.entml_think.parse import (
+    EntmlThinkingStreamFilter,
+    has_unclosed_entml_thinking,
+    split_entml_thinking,
+)
+
+__all__ = [
+    "EntmlThinkingStreamFilter",
+    "apply_thinking_history_policy",
+    "build_entml_thinking_section",
+    "extract_reasoning_text",
+    "format_entml_thinking_history_block",
+    "has_unclosed_entml_thinking",
+    "parse_include_thinking_in_history",
+    "parse_interleaved_history",
+    "parse_max_thinking_length",
+    "split_entml_thinking",
+]

echotools-2.3.40/src/echotools/exec/fncall/protocols/entml_thinking_parse.py → echotools-2.3.42/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -92,6 +92,49 @@ class EntmlThinkingStreamFilter:
             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]
+            emitted = self._emit_thinking_piece(piece)
+            if emitted:
+                out.append(("thinking", emitted))
+            self._in_block = False
+            self._thinking_started = False
+            self._pending = self._pending[close_at + len(_THINKING_CLOSE) :]
+            return True
+
+        safe, hold = _hold_prefix(self._pending, _THINKING_CLOSE)
+        if safe:
+            emitted = self._emit_thinking_piece(safe)
+            if emitted:
+                out.append(("thinking", emitted))
+        self._pending = hold
+        return False
+
+    def _feed_before_block(self, out: List[Tuple[str, str]]) -> bool:
+        """开标签之前或尚未进入块；返回 False 表示应退出 feed 主循环。"""
+        open_at = self._pending.find(_THINKING_OPEN_PREFIX)
+        if open_at < 0:
+            safe, self._pending = _hold_prefix(self._pending, _THINKING_OPEN_PREFIX)
+            if safe:
+                out.append(("content", safe))
+            return False
+
+        if open_at > 0:
+            out.append(("content", self._pending[:open_at]))
+            self._pending = self._pending[open_at:]
+
+        gt = self._pending.find(">")
+        if gt < 0:
+            return False
+
+        self._in_block = True
+        self._thinking_started = False
+        self._pending = self._pending[gt + 1 :]
+        return True
+
     def feed(self, chunk: str) -> List[Tuple[str, str]]:
         """返回 [(kind, text), ...]，kind 为 content 或 thinking。"""
         if not chunk:
@@ -102,46 +145,12 @@ class EntmlThinkingStreamFilter:
 
         while self._pending:
             if self._in_block:
-                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))
-                    self._in_block = False
-                    self._thinking_started = False
-                    self._pending = self._pending[close_at + len(_THINKING_CLOSE) :]
-                    continue
-
-                # 关闭标签可能被分片：hold 真前缀，其余立即作为 thinking 输出
-                safe, hold = _hold_prefix(self._pending, _THINKING_CLOSE)
-                if safe:
-                    emitted = self._emit_thinking_piece(safe)
-                    if emitted:
-                        out.append(("thinking", emitted))
-                self._pending = hold
-                break
-
-            open_at = self._pending.find(_THINKING_OPEN_PREFIX)
-            if open_at < 0:
-                safe, self._pending = _hold_prefix(self._pending, _THINKING_OPEN_PREFIX)
-                if safe:
-                    out.append(("content", safe))
+                if not self._feed_in_block(out):
+                    break
+                continue
+            if not self._feed_before_block(out):
                 break
 
-            if open_at > 0:
-                out.append(("content", self._pending[:open_at]))
-                self._pending = self._pending[open_at:]
-
-            gt = self._pending.find(">")
-            if gt < 0:
-                # 开标签属性未收齐
-                break
-
-            self._in_block = True
-            self._thinking_started = False
-            self._pending = self._pending[gt + 1 :]
-
         return out
 
     def _emit_thinking_piece(self, piece: str) -> str:

{echotools-2.3.40 → echotools-2.3.42}/src/echotools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.3.40
+Version: 2.3.42
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Author: nichengfuben
 License: MIT

{echotools-2.3.40 → echotools-2.3.42}/src/echotools.egg-info/SOURCES.txt

@@ -57,12 +57,12 @@ src/echotools/exec/fncall/protocols/__init__.py
 src/echotools/exec/fncall/protocols/entml.py
 src/echotools/exec/fncall/protocols/entml_invoke.py
 src/echotools/exec/fncall/protocols/entml_patterns.py
-src/echotools/exec/fncall/protocols/entml_sanitize.py
-src/echotools/exec/fncall/protocols/entml_thinking.py
-src/echotools/exec/fncall/protocols/entml_thinking_history.py
-src/echotools/exec/fncall/protocols/entml_thinking_parse.py
 src/echotools/exec/fncall/protocols/entml_tools.py
 src/echotools/exec/fncall/protocols/entml_values.py
+src/echotools/exec/fncall/protocols/entml_think/__init__.py
+src/echotools/exec/fncall/protocols/entml_think/core.py
+src/echotools/exec/fncall/protocols/entml_think/hist.py
+src/echotools/exec/fncall/protocols/entml_think/parse.py
 src/echotools/exec/fncall/shared/__init__.py
 src/echotools/exec/fncall/shared/coercion.py
 src/echotools/exec/fncall/shared/loop_detect.py

{echotools-2.3.40 → echotools-2.3.42}/src/tests/test_entml_protocol.py

@@ -6,7 +6,7 @@ import pytest
 
 from echotools.exec.fncall import get_protocol, inject_fncall
 from echotools.exec.fncall.protocols.entml_invoke import parse_entml_tool_calls
-from echotools.exec.fncall.protocols.entml_thinking import (
+from echotools.exec.fncall.protocols.entml_think.core import (
     build_entml_thinking_section,
     default_max_thinking_length_for_level,
     normalize_thinking_level,
@@ -77,7 +77,7 @@ def test_build_entml_thinking_section_empty_without_options() -> None:
 
 
 def test_parse_max_thinking_length() -> None:
-    from echotools.exec.fncall.protocols.entml_thinking import parse_max_thinking_length
+    from echotools.exec.fncall.protocols.entml_think.core import parse_max_thinking_length
 
     assert parse_max_thinking_length(None) is None
     assert parse_max_thinking_length("") is None
@@ -223,6 +223,33 @@ def test_inject_no_tools_with_thinking_on() -> None:
     assert "<entml:thinking_mode>on</entml:thinking_mode>" in result
     assert "<thinking_behavior>" in result
     assert "Never skip the thinking block" in result
+    # thinking 块必须在 current_user_message 之后
+    assert result.index("</current_user_message>") < result.index("<entml:thinking_mode>")
+
+
+def test_render_prompt_thinking_after_current_user() -> None:
+    proto = get_protocol("entml")
+    prompt = proto.render_prompt(
+        tool_descs=proto.format_tool_descs([
+            {
+                "type": "function",
+                "function": {
+                    "name": "search",
+                    "description": "Search",
+                    "parameters": {"type": "object", "properties": {}},
+                },
+            }
+        ]),
+        lang="en",
+        history_text="<user>\nold\n</user>",
+        current_user_message="new",
+        protocol_options={"thinking_mode": "on", "max_thinking_length": 1000},
+    )
+    assert prompt.index("In this environment") < prompt.index("<entml:conversation_history>")
+    assert prompt.index("<entml:conversation_history>") < prompt.index("<current_user_message>")
+    assert prompt.index("</current_user_message>") < prompt.index("<entml:thinking_mode>")
+    assert prompt.index("<entml:thinking_mode>") < prompt.index("<thinking_behavior>")
+    assert prompt.rstrip().endswith("</thinking_behavior>")
 
 
 def test_inject_with_history_entml_tags() -> None:
@@ -316,7 +343,7 @@ def test_entml_history_tool_invoke_reminder_when_tools_in_history() -> None:
 
 
 def test_strip_entml_from_user_content() -> None:
-    from echotools.exec.fncall.protocols.entml_sanitize import strip_entml_from_content
+    from echotools.exec.fncall.protocols.entml import strip_entml_from_content
 
     raw = (
         "请查天气\n"

{echotools-2.3.40 → echotools-2.3.42}/src/tests/test_entml_thinking_history.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from echotools.exec.fncall.protocols.entml_thinking_history import (
+from echotools.exec.fncall.protocols.entml_think.hist import (
     apply_thinking_history_policy,
     extract_reasoning_text,
     parse_interleaved_history,

{echotools-2.3.40 → echotools-2.3.42}/src/tests/test_entml_thinking_parse.py

@@ -1,4 +1,4 @@
-from echotools.exec.fncall.protocols.entml_thinking_parse import (
+from echotools.exec.fncall.protocols.entml_think.parse import (
     EntmlThinkingStreamFilter,
     has_unclosed_entml_thinking,
     split_entml_thinking,

{echotools-2.3.40 → echotools-2.3.42}/src/tests/test_fncall_stream_thinking.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from echotools.exec.fncall import get_protocol
 from echotools.exec.fncall.parsers.stream import FncallStreamParser
-from echotools.exec.fncall.protocols.entml_thinking_parse import (
+from echotools.exec.fncall.protocols.entml_think.parse import (
     EntmlThinkingStreamFilter,
     has_unclosed_entml_thinking,
     split_entml_thinking,

echotools-2.3.40/src/echotools/exec/fncall/prompt/history_format.py

@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-"""Conversation history block formatting."""
-
-from typing import Any, Dict, List, Optional
-
-from echotools.exec.fncall.shared.normalization import normalize_content
-
-from .prompt_helpers import (
-    format_assistant_block,
-    format_assistant_block_with_results,
-    format_tool_block,
-    format_user_block,
-    join_history_parts,
-)
-
-
-def history_contains_tool_calls(messages: List[Dict[str, Any]]) -> bool:
-    """历史消息中是否包含 assistant tool_calls 或 tool 结果。"""
-    for m in messages:
-        role = m.get("role") or "user"
-        if role == "assistant" and m.get("tool_calls"):
-            return True
-        if role == "tool":
-            return True
-    return False
-
-
-def _format_conversation_history(
-    messages: List[Dict[str, Any]],
-    protocol: Optional[Any] = None,
-    *,
-    include_thinking_in_history: bool = False,
-) -> str:
-    if not messages:
-        return ""
-
-    call_id_to_name: Dict[str, str] = {}
-    seen_assistant_keys = set()
-    parts: List[tuple] = []
-    clean_fn = protocol.clean_tags if protocol and hasattr(protocol, "clean_tags") else None
-
-    i = 0
-    while i < len(messages):
-        m = messages[i]
-        role: str = m.get("role") or "user"
-        content_str = normalize_content(m.get("content", ""))
-
-        if role == "user":
-            parts.append((format_user_block(content_str, clean_fn), False))
-            i += 1
-            continue
-
-        if role == "assistant":
-            tcs = m.get("tool_calls") or []
-            if tcs:
-                # collect immediately following tool messages
-                tool_msgs = []
-                j = i + 1
-                while j < len(messages) and (messages[j].get("role") or "user") == "tool":
-                    tool_msgs.append(messages[j])
-                    j += 1
-                blocks = format_assistant_block_with_results(
-                    m, tool_msgs, protocol, call_id_to_name, seen_assistant_keys,
-                    include_thinking_in_history=include_thinking_in_history,
-                )
-                for block in blocks:
-                    parts.append((block, False))
-                i = j
-            else:
-                blocks = format_assistant_block(
-                    m, content_str, protocol, call_id_to_name, seen_assistant_keys,
-                    include_thinking_in_history=include_thinking_in_history,
-                )
-                for block in blocks:
-                    parts.append((block, False))
-                i += 1
-            continue
-
-        if role == "tool":
-            # orphan tool message (not consumed above)
-            parts.append((format_tool_block(m, content_str, call_id_to_name), True))
-            i += 1
-            continue
-
-        parts.append((f"<{role}>\n{content_str}\n</{role}>", False))
-        i += 1
-
-    return join_history_parts(parts)