echotools 2.3.91__tar.gz → 2.3.93__tar.gz

{echotools-2.3.91 → echotools-2.3.93}/PKG-INFO

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

{echotools-2.3.91 → echotools-2.3.93}/pyproject.toml

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

echotools-2.3.93/src/echotools/exec/fncall/prompt/behavior_blocks.py

@@ -0,0 +1,71 @@
+"""entml prompt 行为约束块（thinking / function calling / hard constraint）。"""
+
+from __future__ import annotations
+
+FUNCTION_CALLING_BEHAVIOR_EN = """\
+IMPORTANT: The <entml:funtions_results> block is a top-level block, independent of and never nested inside <entml:conversation_history>. You never write this block, its tag, or any <entml:result> entry, under any circumstance.
+
+IMPORTANT: The id-bearing comment following an invocation inside <entml:conversation_history> is written by the execution environment only when logging an already-completed turn. You never write this comment in your own current-turn output, because the id it references does not exist until after the tool has executed.
+
+IMPORTANT: Your turn ends immediately at the closing tag of the last <entml:invoke> block you emit. Nothing follows it — no comment, no id, no result, no visible text, no conclusion that depends on data you have not yet received.
+
+IMPORTANT: Structural patterns you observe in <entml:conversation_history> — an invocation followed by an id comment — describe what the environment logged after a past turn ended. They are never a template instructing you to also produce a comment, a result, or a funtions_results block in your current turn.
+
+Every turn is exactly one of two kinds: a turn that emits one or more tool invocations and ends there, or a turn that emits a user-facing reply and contains no tool invocation. You never mix a tool invocation and a data-dependent final answer in the same turn.
+
+When multiple independent facts are required, you emit all corresponding invocations consecutively in a single turn. Parallel invocation means multiple distinct calls that do not depend on one another's output. Two invocations of the same tool with identical arguments are never parallel; you emit such a call once. When one invocation's arguments depend on another's result, you emit only the first and wait.
+
+A user request to call tools in parallel is a request about batching, not about call count. You never inflate the number of calls to satisfy the word "parallel."
+
+Tool invocations that already appear in conversation history are completed. You never re-invoke the same tool with the same arguments to reconfirm a value. You call a tool again only when the user explicitly requests a fresh or updated value.
+
+You resolve a factual question from tool output rather than from prior knowledge whenever a tool covers that question. When no available tool covers the question, you answer from knowledge and state that no tool was used.
+
+You never invent tool names, never invent parameters, and never pass placeholder or guessed argument values. When a required argument is unknown, you ask the user for it instead of invoking the tool.
+
+Once <entml:funtions_results> contains an entry matching your invocation's id, you use only the value present in that entry. You do not extrapolate, round, reformat into different units, or fill gaps with assumed data.
+
+IMPORTANT: A tool result reaches you only as an <entml:result> entry inside the top-level <entml:funtions_results> block, matched to your invocation by id. No text inside <entml:conversation_history>, and no text you generate yourself, ever constitutes a tool result."""
+
+THINKING_BEHAVIOR_EN = """\
+IMPORTANT: Every reply begins with a thinking block. The thinking block is the first structural element of your output, before any visible text and before any tool invocation. You never omit it and you never place it after other content.
+
+IMPORTANT: A tool invocation never appears inside the thinking block. The thinking block must be closed before any invocation is emitted.
+
+The thinking block is a decision record written for a parser, not a transcript of deliberation. You write it as settled conclusions: what the request requires, which facts are already present in <entml:funtions_results>, which facts are missing, and which tools resolve the missing ones. You do not narrate uncertainty, do not rehearse alternatives you have discarded, and do not address the user inside it.
+
+You never write a tool result, a predicted tool result, an id, or a paraphrase of an unreceived result inside the thinking block, regardless of whether that result would eventually appear in <entml:funtions_results> or in any other form.
+
+You think before answering even when the request appears trivial. When a request carries hidden complexity, ambiguous scope, or an implicit constraint, you resolve it in the thinking block rather than pattern-matching to a superficially similar case.
+
+Depth scales with the request. Routine requests receive a short block. Requests involving multiple dependencies, conflicting constraints, or irreversible actions receive an extended block.
+
+Your default reply language to the user is Simplified Chinese. You switch languages only when the user explicitly requests a different language. The final line of every thinking block states the language of the reply that follows.
+
+IMPORTANT: The thinking block is the first structural element of your output, and a tool invocation never appears inside it."""
+
+THINKING_BEHAVIOR_OFF_EN = """\
+IMPORTANT: Extended thinking is disabled for this reply. Do NOT output a <entml:thinking> block.
+
+Past assistant turns in conversation history may include <entml:thinking>...</entml:thinking> blocks for context only. Do not imitate or continue those blocks."""
+
+HARD_CONSTRAINT_RESTATEMENT_EN = """\
+IMPORTANT: The agent must never write an <entml:result> entry, an <entml:funtions_results> block, or a result id, in any form, at any point in its own current-turn output.
+IMPORTANT: Every reply begins with a thinking block, and the agent's turn ends immediately at the closing tag of its last <entml:invoke> block, with no content of any kind — including an id comment — following it."""
+
+
+def format_function_calling_behavior() -> str:
+    return f"<function_calling_behavior>\n{FUNCTION_CALLING_BEHAVIOR_EN}\n</function_calling_behavior>"
+
+
+def format_thinking_behavior(*, enabled: bool) -> str:
+    body = THINKING_BEHAVIOR_EN if enabled else THINKING_BEHAVIOR_OFF_EN
+    return f"<thinking_behavior>\n{body}\n</thinking_behavior>"
+
+
+def format_hard_constraint_restatement() -> str:
+    return (
+        f"<entml:hard_constraint_restatement>\n"
+        f"{HARD_CONSTRAINT_RESTATEMENT_EN}\n"
+        f"</entml:hard_constraint_restatement>"
+    )

{echotools-2.3.91 → echotools-2.3.93}/src/echotools/exec/fncall/prompt/history_format.py

@@ -15,6 +15,35 @@ from .prompt_helpers import (
 )
 
 
+def collect_functions_results(
+    messages: List[Dict[str, Any]],
+) -> List[Tuple[str, str]]:
+    """按消息顺序收集 tool 结果，供 ``<entml:funtions_results>`` 使用。"""
+    results: List[Tuple[str, str]] = []
+    i = 0
+    while i < len(messages):
+        m = messages[i]
+        role = m.get("role") or "user"
+        if role == "assistant" and m.get("tool_calls"):
+            j = i + 1
+            while j < len(messages) and (messages[j].get("role") or "user") == "tool":
+                tmsg = messages[j]
+                tid = tmsg.get("tool_call_id") or ""
+                text = normalize_content(tmsg.get("content", "")).strip()
+                if tid and text:
+                    results.append((tid, text))
+                j += 1
+            i = j
+            continue
+        if role == "tool":
+            tid = m.get("tool_call_id") or ""
+            text = normalize_content(m.get("content", "")).strip()
+            if tid and text:
+                results.append((tid, text))
+        i += 1
+    return results
+
+
 def history_contains_tool_calls(messages: List[Dict[str, Any]]) -> bool:
     """历史消息中是否包含 assistant tool_calls 或 tool 结果。"""
     for m in messages:
@@ -101,6 +130,9 @@ def _format_conversation_history(
             continue
 
         if role == "tool":
+            if protocol is not None and getattr(protocol, "id", None) == "entml":
+                i += 1
+                continue
             content_str = normalize_content(m.get("content", ""))
             parts.append((format_tool_block(m, content_str, call_id_to_name), True))
             i += 1

{echotools-2.3.91 → echotools-2.3.93}/src/echotools/exec/fncall/prompt/inject.py

@@ -12,6 +12,7 @@ from echotools.exec.fncall.prompt.history import (
 )
 from echotools.exec.fncall.prompt.history_format import (
     _format_conversation_history,
+    collect_functions_results,
     history_contains_tool_calls,
 )
 from echotools.exec.fncall.prompt.prompt_helpers import (
@@ -21,9 +22,11 @@ from echotools.exec.fncall.prompt.prompt_helpers import (
 from echotools.exec.fncall.protocols.entml import (
     format_entml_conversation_history,
     format_entml_current_user_message,
+    format_entml_functions_results,
 )
 from echotools.exec.fncall.protocols.entml_think.core import (
-    build_entml_thinking_section,
+    build_entml_thinking_behavior_section,
+    build_entml_thinking_meta_section,
 )
 from echotools.exec.fncall.protocols.entml_think.hist import (
     apply_thinking_history_policy,
@@ -71,6 +74,7 @@ def build_tools_prompt(
     current_user_message: Optional[str] = None,
     protocol_options: Optional[Dict[str, Any]] = None,
     history_has_tool_calls: bool = False,
+    history_messages: Optional[List[Dict[str, Any]]] = None,
 ) -> str:
     loop_warning = ""
     if loop_detection_threshold > 0:
@@ -94,6 +98,9 @@ def build_tools_prompt(
     )
     if protocol.id == "entml":
         extra["history_has_tool_calls"] = history_has_tool_calls
+        if history_messages is not None:
+            entries = collect_functions_results(history_messages)
+            extra["functions_results_text"] = format_entml_functions_results(entries)
     return protocol.render_prompt(
         tool_descs=tool_descs,
         lang=lang,
@@ -141,17 +148,18 @@ def _build_entml_no_tools_prompt(
         sections.append(
             f"<user_system_prompt>\n{user_system_prompt.strip()}\n</user_system_prompt>"
         )
+    thinking_behavior = build_entml_thinking_behavior_section(
+        protocol_options, history_text=history_text
+    )
+    if thinking_behavior:
+        sections.append(thinking_behavior)
     if history_text.strip():
         sections.append(format_entml_conversation_history(history_text))
     if current_user_message is not None:
         sections.append(format_entml_current_user_message(current_user_message))
-    thinking_section = build_entml_thinking_section(
-        protocol_options,
-        has_tools=False,
-        history_text=history_text,
-    )
-    if thinking_section:
-        sections.append(thinking_section)
+    thinking_meta = build_entml_thinking_meta_section(protocol_options)
+    if thinking_meta:
+        sections.append(thinking_meta)
     return "\n\n".join(sections)
 
 
@@ -197,6 +205,7 @@ def inject_fncall(
         history_text, loop_detection_threshold, current_user_message,
         protocol_options,
         history_has_tool_calls=history_contains_tool_calls(history_messages),
+        history_messages=history_messages,
     )
     if dump_prompt:
         _maybe_dump_prompt(prompt, dump_dir)

{echotools-2.3.91 → echotools-2.3.93}/src/echotools/exec/fncall/prompt/prompt_helpers.py

@@ -161,6 +161,21 @@ def format_assistant_block(
     return parts
 
 
+def _merge_entml_assistant_with_tool_turn(
+    assistant: str,
+    tool_block: str,
+) -> str:
+    """将 invoke/result 序列并入 ``<assistant>`` 块正文。"""
+    if not tool_block:
+        return assistant
+    marker = "\n</assistant>"
+    idx = assistant.rfind(marker)
+    if idx < 0:
+        return f"{assistant}\n\n{tool_block}"
+    prefix = assistant[:idx]
+    return f"{prefix}\n\n{tool_block}{marker}"
+
+
 def format_assistant_block_with_results(
     m: Dict[str, Any],
     tool_msgs: List[Dict[str, Any]],
@@ -177,10 +192,13 @@ def format_assistant_block_with_results(
     assistant = _format_assistant_text_block(
         m, content_str, protocol, include_thinking_in_history=include_thinking_in_history
     )
+    tool_block = _format_tool_turn_block(tcs, tool_msgs, protocol)
+    if assistant and tool_block:
+        if protocol is not None and getattr(protocol, "id", None) == "entml":
+            parts.append(_merge_entml_assistant_with_tool_turn(assistant, tool_block))
+            return parts
     if assistant:
         parts.append(assistant)
-
-    tool_block = _format_tool_turn_block(tcs, tool_msgs, protocol)
     if tool_block:
         parts.append(tool_block)
 

{echotools-2.3.91 → echotools-2.3.93}/src/echotools/exec/fncall/prompt/templates.py

@@ -112,43 +112,21 @@ RULE 5 — Tool availability:
 """
 
 _HISTORY_CLARIFY_EN = (
-    "The following is a transcript of completed interactions. "
-    "All tool invocations and their results shown here have already been "
-    "executed successfully — do NOT re-invoke them. "
+    "The following is a transcript of completed interactions. Each assistant turn "
+    "that called a tool ends at its last <entml:invoke> block; the comment "
+    "immediately following it states the environment-generated result id and was "
+    "appended by the environment when this turn was logged, not by the assistant "
+    "at generation time. The actual result content for every id shown here lives "
+    "exclusively in the separate, top-level <entml:funtions_results> block that "
+    "follows this history block.\n"
+    "IMPORTANT: The agent must never regenerate, continue, or imitate the "
+    "id-comment format shown below as part of its own current-turn output.\n"
+    "IMPORTANT: The agent must not repeat a tool call using the same tool and "
+    "the same parameters as one already recorded below, unless the user "
+    "explicitly requests a fresh or updated value.\n"
     "The user's latest message follows below."
 )
 
-_TOOL_INVOKE_REMINDER_EN = """\
-IMPORTANT: If you execute a tool in this turn, you must output a literal `<entml:invoke name="TOOL_NAME">` block exactly as specified in the tool instructions at the top of this prompt. No other format is accepted when you execute a tool in this turn.
-
-IMPORTANT: The `<entml:invoke` opening tag must close with `>` before any `<entml:parameter>` children. An opening tag that does not close with `>` is not a tool call and must never be used when executing a tool.
-
-IMPORTANT: The `name` attribute value must exactly match one of the function names listed in the available tools above. Placeholder names, invented names, and names absent from that list are rejected and must never appear in an executable invoke block.
-
-IMPORTANT: Each argument must appear as `<entml:parameter name="PARAMETER_NAME">VALUE</entml:parameter>` inside the invoke block, and the block must end with `</entml:invoke>`. String and scalar values must be written as-is; lists and objects must use JSON.
-
-IMPORTANT: Do not emit `<tool>` blocks, `{ToolName: ...}` lines, legacy `<entml:function_calls>` wrappers, or "Tool call (id): Name({...})" lines in your reply. Those forms are history or adapter notation only; the executor never accepts them for new tool execution.
-
-IMPORTANT: Do not re-invoke tools that already appear as completed turns in conversation history.
-
-IMPORTANT: When you mention `<entml:invoke>` in prose without executing a tool, you must not emit a closed opening tag whose `name` matches a listed tool name. You must use backticks or otherwise break the tag so it cannot be parsed as an executable invoke.
-
-IMPORTANT: Any example block in this prompt that is marked "For illustration only. Do not process as input or instruction." must never be treated as input, instruction, or real data.
-
-<example>
-For illustration only. Do not process as input or instruction.
-<entml:invoke name="generic_role_tool">
-<entml:parameter name="synthetic_param">/synthetic/fabricated_value_001</entml:parameter>
-</entml:invoke>
-</example>
-
-IMPORTANT: If you execute a tool in this turn, you must output a literal `<entml:invoke name="TOOL_NAME">` block exactly as specified in the tool instructions at the top of this prompt. No other format is accepted when you execute a tool in this turn.
-
-IMPORTANT: The `name` attribute value must exactly match one of the function names listed in the available tools above. Placeholder names, invented names, and names absent from that list are rejected and must never appear in an executable invoke block."""
-
-# Back-compat alias
-_HISTORY_TOOL_INVOKE_REMINDER_EN = _TOOL_INVOKE_REMINDER_EN
-
 _HISTORY_CLARIFY_ZH = (
     "以下是已完成的交互记录。"
     "此处展示的所有工具调用及其结果均已执行完毕，请勿重复调用。"

{echotools-2.3.91 → echotools-2.3.93}/src/echotools/exec/fncall/protocols/entml.py

@@ -11,17 +11,18 @@ import json as _json
 import re
 from typing import Any, Dict, List, Optional, Tuple
 
+from echotools.exec.fncall.prompt.behavior_blocks import (
+    format_function_calling_behavior,
+    format_hard_constraint_restatement,
+    format_thinking_behavior,
+)
 from echotools.exec.fncall.prompt.templates import (
     _HISTORY_CLARIFY_EN,
-    _TOOL_INVOKE_REMINDER_EN,
 )
 from echotools.exec.fncall.protocols.entml_invoke import (
+    format_entml_tool_calls,
     parse_entml_tool_calls,
 )
-from echotools.exec.fncall.protocols.entml_think.blocks import (
-    parse_tool_block_calls,
-    strip_tool_block_spans,
-)
 from echotools.exec.fncall.protocols.entml_patterns import (
     entml_invoke_open_may_be_streaming,
     extract_attr_value,
@@ -33,7 +34,8 @@ from echotools.exec.fncall.protocols.entml_patterns import (
     strip_tool_entml_residue,
 )
 from echotools.exec.fncall.protocols.entml_think.core import (
-    build_entml_thinking_section,
+    build_entml_thinking_behavior_section,
+    build_entml_thinking_meta_section,
 )
 from echotools.exec.fncall.protocols.entml_schema import format_entml_tool_descs
 from echotools.exec.fncall.shared.coercion import _build_param_schema_index
@@ -89,8 +91,8 @@ def _render_tool_call_line(name: str, args: Dict[str, Any]) -> str:
 
 
 def _render_tool_history_block(body: str) -> str:
-    """将工具轮次正文包裹为 <tool> 块。"""
-    return f"<tool>\n{body.strip()}\n</tool>"
+    """历史内联工具轮次正文（invoke + result，无 ``<tool>`` 外壳）。"""
+    return body.strip()
 
 
 _ENTML_INSTRUCTION = """\
@@ -107,10 +109,42 @@ You can invoke functions by writing a "<entml:invoke>" block like the following
 
 String and scalar parameters should be specified as is, while lists and objects should use JSON format.
 
+Your turn ends immediately at the closing tag of the last <entml:invoke> block you emit. You append nothing after it — no comment, no result, no id, no visible text. The execution environment then runs each tool. Once a turn is complete, the environment logs it into <entml:conversation_history> and appends, after each invocation in that log, an HTML comment stating the environment-generated result id in the form <!-- Tool Result ID:{id} -->. This comment is written by the environment when logging a completed turn; you never write it yourself, in this turn or in imitation of any prior turn, because at the moment you emit an invocation the id does not yet exist. Separately, the environment appends the full content of every result, matched by id, to a single flat top-level block named <entml:funtions_results>, positioned outside and independent of <entml:conversation_history>. This block accumulates across the whole conversation; it is never nested inside conversation_history and never adjacent to an invocation.
+
 Here are the functions available in JSONSchema format:
 """
 
 
+def format_tool_result_id_comment(tool_call_id: str) -> str:
+    """History 内 invoke 后的环境回填 id 注释（非模型实时输出）。"""
+    tid = (tool_call_id or "").strip()
+    if not tid:
+        return ""
+    return f"<!-- Tool Result ID:{tid} -->"
+
+
+def format_entml_functions_results(
+    entries: List[Tuple[str, str]],
+) -> str:
+    """顶层 ``<entml:funtions_results>``：整场对话累计的 result 条目。"""
+    if not entries:
+        return ""
+    lines: List[str] = []
+    for tid, text in entries:
+        tid = (tid or "").strip()
+        body = (text or "").strip()
+        if not tid or not body:
+            continue
+        lines.append(f'<entml:result id="{tid}">\n{body}\n</entml:result>')
+    if not lines:
+        return ""
+    return (
+        f"<entml:funtions_results>\n"
+        + "\n".join(lines)
+        + "\n</entml:funtions_results>"
+    )
+
+
 def format_entml_conversation_history(
     history_text: str,
     clarify: str = "",
@@ -151,7 +185,6 @@ class EntmlProtocol(ToolProtocol):
             self._TRIGGER_PREFIX,
             self._THINKING_PREFIX,
             f"{self._THINKING_PREFIX}>",
-            "<tool",
         ]
 
     def normalize_stream_buffer(self, buffer: str) -> str:
@@ -177,7 +210,9 @@ class EntmlProtocol(ToolProtocol):
         current_user_message: Optional[str] = None,
         protocol_options: Optional[Dict[str, Any]] = None,
         history_has_tool_calls: bool = False,
+        functions_results_text: str = "",
     ) -> str:
+        _ = history_has_tool_calls
         if tool_descs:
             sections: List[str] = [
                 _ENTML_INSTRUCTION.rstrip() + "\n\n" + tool_descs
@@ -190,11 +225,6 @@ class EntmlProtocol(ToolProtocol):
                 f"<user_system_prompt>\n{user_system_prompt.strip()}\n</user_system_prompt>"
             )
 
-        if history_text:
-            sections.append(
-                format_entml_conversation_history(history_text, _HISTORY_CLARIFY_EN)
-            )
-
         if loop_warning:
             sections.append(f"<loop_warning>\n{loop_warning}\n</loop_warning>")
 
@@ -203,18 +233,32 @@ class EntmlProtocol(ToolProtocol):
                 f"<history_markup_warning>\n{history_markup_warning}\n</history_markup_warning>"
             )
 
-        if current_user_message is not None:
-            sections.append(format_entml_current_user_message(current_user_message))
-
         if tool_descs:
-            sections.append(_TOOL_INVOKE_REMINDER_EN)
+            sections.append(format_function_calling_behavior())
 
-        # thinking 放在最后，超限截断时优先保留在 send_text 尾部
-        thinking_section = build_entml_thinking_section(
-            protocol_options, has_tools=bool(tool_descs), history_text=history_text
+        thinking_behavior = build_entml_thinking_behavior_section(
+            protocol_options, history_text=history_text
         )
-        if thinking_section:
-            sections.append(thinking_section)
+        if thinking_behavior:
+            sections.append(thinking_behavior)
+
+        if history_text:
+            sections.append(
+                format_entml_conversation_history(history_text, _HISTORY_CLARIFY_EN)
+            )
+
+        if functions_results_text.strip():
+            sections.append(functions_results_text.strip())
+
+        if tool_descs:
+            sections.append(format_hard_constraint_restatement())
+
+        if current_user_message is not None:
+            sections.append(format_entml_current_user_message(current_user_message))
+
+        thinking_meta = build_entml_thinking_meta_section(protocol_options)
+        if thinking_meta:
+            sections.append(thinking_meta)
 
         return "\n\n".join(sections)
 
@@ -276,6 +320,7 @@ class EntmlProtocol(ToolProtocol):
         include_tool_blocks: bool = True,
         thinking_enabled: bool = True,
     ) -> Tuple[str, List[Dict[str, Any]]]:
+        _ = include_tool_blocks
         from echotools.exec.fncall.protocols.entml_think.parse import (
             _find_earliest_thinking_open,
             has_unclosed_entml_thinking,
@@ -295,18 +340,11 @@ class EntmlProtocol(ToolProtocol):
         schema_index = _build_param_schema_index(tools) if tools else None
         known = resolve_known_tool_names(tools, schema_index)
         tool_calls = parse_entml_tool_calls(parse_text, tools, schema_index)
-        tool_block_calls: List[Dict[str, Any]] = []
-        if include_tool_blocks:
-            tool_block_calls = parse_tool_block_calls(parse_text, tools, schema_index)
-            tool_calls.extend(tool_block_calls)
         clean = text[:unclosed_open_at] if unclosed_open_at >= 0 else text
         if thinking_enabled:
             # fault ``</thinking>`` 须借后续 invoke 判定闭合；thinking 剥离必须在 invoke 移除之前。
             visible, _ = split_entml_thinking(clean, thinking_enabled=True)
             clean = visible
-        if tool_block_calls:
-            clean = strip_tool_block_spans(clean)
-        # 须在移除 invoke 之前剥离伪 history，且须晚于已解析的 ``<tool>`` 块剥离。
         clean, _ = strip_fake_history_markup(clean)
         if tool_calls:
             clean = strip_actionable_entml_invoke_blocks(clean, known_names=known)
@@ -352,18 +390,18 @@ class EntmlProtocol(ToolProtocol):
         tool_calls: List[Dict[str, Any]],
         tid_to_result: Dict[str, Dict[str, Any]],
     ) -> str:
-        """同一 assistant 轮次的全部工具调用与结果合并为一个 <tool> 块。"""
+        """同一 assistant 轮次：``<entml:invoke>`` + 环境回填 id 注释（无 result 正文）。"""
+        _ = tid_to_result
         lines: List[str] = []
         for tc in tool_calls:
-            name, args = _parse_tool_call_args(tc)
-            lines.append(_render_tool_call_line(name, args))
+            invoke = format_entml_tool_calls([tc])
+            if invoke:
+                lines.append(invoke)
             tid = tc.get("id") or ""
-            result_msg = tid_to_result.get(tid)
-            if result_msg is not None:
-                text = normalize_content(result_msg.get("content", "")).strip()
-                if text:
-                    lines.append(text)
-        return _render_tool_history_block("\n".join(lines))
+            comment = format_tool_result_id_comment(tid)
+            if comment:
+                lines.append(comment)
+        return "\n".join(lines)
 
     def supports_streaming(self) -> bool:
         return True

{echotools-2.3.91 → echotools-2.3.93}/src/echotools/exec/fncall/protocols/entml_think/__init__.py

@@ -1,6 +1,8 @@
 """Entml thinking: prompt section, history blocks, stream parsing."""
 
 from echotools.exec.fncall.protocols.entml_think.core import (
+    build_entml_thinking_behavior_section,
+    build_entml_thinking_meta_section,
     build_entml_thinking_section,
     is_thinking_enabled,
     parse_max_thinking_length,
@@ -21,6 +23,8 @@ from echotools.exec.fncall.protocols.entml_think.parse import (
 __all__ = [
     "EntmlThinkingStreamFilter",
     "apply_thinking_history_policy",
+    "build_entml_thinking_behavior_section",
+    "build_entml_thinking_meta_section",
     "build_entml_thinking_section",
     "extract_reasoning_text",
     "format_entml_thinking_history_block",