echotools 2.4.1__tar.gz → 2.4.2__tar.gz

{echotools-2.4.1 → echotools-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.4.1
+Version: 2.4.2
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Home-page: https://github.com/nichengfuben/echotools
 Author: nichengfuben
@@ -58,7 +58,7 @@ Requires-Dist: ruff>=0.4.0; extra == "dev"
 
 通用基础设施 SDK：配置、日志、事件、调度、插件、调用链，以及 **entml** LLM 工具调用协议与终端 Console UI。
 
-完全项目无关，兼容 Python 3.8–3.14。当前版本：**2.4.1**（详见 [CHANGELOG](docs/CHANGELOG.md)）。
+完全项目无关，兼容 Python 3.8–3.14。当前版本：**2.4.2**（详见 [CHANGELOG](docs/CHANGELOG.md)）。
 
 ## 安装
 

{echotools-2.4.1 → echotools-2.4.2}/README.md

@@ -2,7 +2,7 @@
 
 通用基础设施 SDK：配置、日志、事件、调度、插件、调用链，以及 **entml** LLM 工具调用协议与终端 Console UI。
 
-完全项目无关，兼容 Python 3.8–3.14。当前版本：**2.4.1**（详见 [CHANGELOG](docs/CHANGELOG.md)）。
+完全项目无关，兼容 Python 3.8–3.14。当前版本：**2.4.2**（详见 [CHANGELOG](docs/CHANGELOG.md)）。
 
 ## 安装
 

{echotools-2.4.1 → echotools-2.4.2}/pyproject.toml

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

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/prompt/prompt_helpers.py

@@ -18,6 +18,18 @@ from .history import (
 )
 
 
+def _clean_assistant_history_content(
+    content_str: str,
+    protocol: Optional[Any],
+) -> str:
+    if not content_str or protocol is None:
+        return content_str
+    clean_fn = getattr(protocol, "clean_history_assistant_content", None)
+    if clean_fn is None:
+        return content_str
+    return clean_fn(content_str)
+
+
 def _assistant_history_content_blocks(
     m: Dict[str, Any],
     content_str: str,
@@ -33,11 +45,12 @@ def _assistant_history_content_blocks(
     ):
         reasoning = extract_reasoning_text(m)
         if reasoning:
+            reasoning = _clean_assistant_history_content(reasoning, protocol)
             thinking_block = format_entml_thinking_history_block(reasoning)
             if thinking_block:
                 blocks.append(thinking_block)
     if content_str:
-        blocks.append(content_str)
+        blocks.append(_clean_assistant_history_content(content_str, protocol))
     return blocks
 
 

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/protocols/entml.py

@@ -18,6 +18,7 @@ from echotools.exec.fncall.protocols.entml_patterns import (
 )
 from echotools.exec.fncall.protocols.entml_schema import format_entml_tool_descs
 from echotools.exec.fncall.protocols.entml_tool.fakemarkup import (
+    strip_fake_entml_structure_markup,
     strip_orphan_entml_close_tags,
 )
 from echotools.exec.fncall.protocols.entml_tool.invoke import (
@@ -179,6 +180,7 @@ class EntmlProtocol(ToolProtocol):
         if tool_calls:
             clean = strip_actionable_entml_invoke_blocks(clean, known_names=known)
         clean = strip_tool_entml_residue(clean, known_names=known)
+        clean, _ = strip_fake_entml_structure_markup(clean)
         clean, _ = strip_orphan_entml_close_tags(clean)
         return (clean, normalize_tool_calls(tool_calls, tools))
 
@@ -193,6 +195,14 @@ class EntmlProtocol(ToolProtocol):
     def clean_tags(self, content: str) -> str:
         return strip_entml_from_content(content)
 
+    def clean_history_assistant_content(self, content: str) -> str:
+        """构建 conversation_history 时清理 assistant 正文（伪 history 块 + fakemarkup）。"""
+        if not content:
+            return content
+        cleaned, _ = strip_fake_history_markup(content)
+        cleaned, _ = strip_fake_entml_structure_markup(cleaned)
+        return cleaned
+
     def clean_tool_tags(
         self,
         content: str,
@@ -202,6 +212,8 @@ class EntmlProtocol(ToolProtocol):
         known = resolve_known_tool_names(tools, schema_index)
         cleaned = strip_tool_entml_residue(content, known_names=known)
         cleaned, _ = strip_fake_history_markup(cleaned)
+        cleaned, _ = strip_fake_entml_structure_markup(cleaned)
+        cleaned, _ = strip_orphan_entml_close_tags(cleaned)
         return cleaned
 
     def format_assistant_tool_calls(

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/protocols/entml_patterns/params.py

@@ -192,7 +192,7 @@ def parse_sub_tags(
     args: Dict[str, Any] = {}
     for m in SUB_TAG_RE.finditer(content):
         pname = m.group(1).strip()
-        pval = m.group(2).strip()
+        pval = m.group(2) or ""
         pschema = schema_index.get(func_name, {}).get(pname, {}) if schema_index else {}
         args[pname] = coerce_entml_parameter_value(pval, pschema or None)
     return args

echotools-2.4.2/src/echotools/exec/fncall/protocols/entml_schema/validate.py

@@ -0,0 +1,218 @@
+"""JSON Schema 边界校验（coerce 之后）：enum、null union、基础类型匹配。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence
+
+_SCALAR_CHECK = {
+    "string": lambda v: isinstance(v, str),
+    "integer": lambda v: isinstance(v, int) and not isinstance(v, bool),
+    "number": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool),
+    "boolean": lambda v: isinstance(v, bool),
+    "null": lambda v: v is None,
+    "array": lambda v: isinstance(v, list),
+    "object": lambda v: isinstance(v, dict),
+}
+
+
+@dataclass(frozen=True)
+class ParamValidationIssue:
+    path: str
+    message: str
+
+    def to_llm_feedback(self) -> str:
+        loc = self.path or "(root)"
+        return f"Parameter validation failed at {loc}: {self.message}"
+
+
+class ToolArgValidationError(Exception):
+    """工具参数未通过 schema 校验（可回灌模型自修正）。"""
+
+    def __init__(
+        self,
+        issues: Sequence[ParamValidationIssue],
+        *,
+        tool_name: str = "",
+    ) -> None:
+        self.tool_name = tool_name
+        self.issues = list(issues)
+        detail = "; ".join(i.message for i in self.issues)
+        super().__init__(detail or "tool argument validation failed")
+
+    def to_llm_feedback(self) -> str:
+        lines = [i.to_llm_feedback() for i in self.issues]
+        prefix = f"Tool {self.tool_name!r} arguments invalid." if self.tool_name else ""
+        body = "\n".join(lines)
+        return f"{prefix}\n{body}".strip() if prefix else body
+
+
+def schema_allows_null(schema: Dict[str, Any]) -> bool:
+    if not schema:
+        return False
+    raw_type = schema.get("type")
+    if raw_type == "null":
+        return True
+    if isinstance(raw_type, list) and "null" in raw_type:
+        return True
+    for key in ("anyOf", "oneOf"):
+        combiner = schema.get(key)
+        if not isinstance(combiner, list):
+            continue
+        for sub in combiner:
+            if isinstance(sub, dict) and sub.get("type") == "null":
+                return True
+    return False
+
+
+def is_null_literal(raw: str) -> bool:
+    if raw is None:
+        return True
+    return raw.strip().lower() in ("", "null", "none")
+
+
+def _enum_values(schema: Dict[str, Any]) -> Optional[List[Any]]:
+    enum_vals = schema.get("enum")
+    if isinstance(enum_vals, list) and enum_vals:
+        return list(enum_vals)
+    return None
+
+
+def _type_names(schema: Dict[str, Any]) -> List[str]:
+    raw_type = schema.get("type")
+    if isinstance(raw_type, str) and raw_type:
+        return [raw_type]
+    if isinstance(raw_type, list):
+        return [t for t in raw_type if isinstance(t, str)]
+    enum_vals = schema.get("enum")
+    if isinstance(enum_vals, list) and enum_vals:
+        first = enum_vals[0]
+        if isinstance(first, bool):
+            return ["boolean"]
+        if isinstance(first, int):
+            return ["integer"]
+        if isinstance(first, float):
+            return ["number"]
+        if isinstance(first, str):
+            return ["string"]
+        if isinstance(first, list):
+            return ["array"]
+        if isinstance(first, dict):
+            return ["object"]
+    for combiner_key in ("anyOf", "oneOf"):
+        combiner = schema.get(combiner_key)
+        if not isinstance(combiner, list):
+            continue
+        names: List[str] = []
+        for sub in combiner:
+            if isinstance(sub, dict):
+                names.extend(_type_names(sub))
+        if names:
+            return list(dict.fromkeys(names))
+    return []
+
+
+def _value_matches_types(value: Any, type_names: Sequence[str]) -> bool:
+    if not type_names:
+        return True
+    if value is None:
+        return "null" in type_names
+    for name in type_names:
+        if name == "null":
+            continue
+        checker = _SCALAR_CHECK.get(name)
+        if checker and checker(value):
+            return True
+    return False
+
+
+def validate_param_value(
+    value: Any,
+    schema: Dict[str, Any],
+    *,
+    path: str = "",
+) -> List[ParamValidationIssue]:
+    if not schema:
+        return []
+    issues: List[ParamValidationIssue] = []
+    enum_vals = _enum_values(schema)
+    if enum_vals is not None and value not in enum_vals:
+        issues.append(
+            ParamValidationIssue(
+                path,
+                f"value {value!r} is not one of {enum_vals!r}",
+            )
+        )
+    type_names = _type_names(schema)
+    if type_names and not _value_matches_types(value, type_names):
+        issues.append(
+            ParamValidationIssue(
+                path,
+                f"value {value!r} (type {type(value).__name__}) "
+                f"does not match schema types {list(type_names)!r}",
+            )
+        )
+    if isinstance(value, dict):
+        props = schema.get("properties") or {}
+        if isinstance(props, dict):
+            for key, sub_schema in props.items():
+                if not isinstance(sub_schema, dict):
+                    continue
+                sub_path = f"{path}.{key}" if path else key
+                if key in value:
+                    issues.extend(
+                        validate_param_value(value[key], sub_schema, path=sub_path)
+                    )
+    if isinstance(value, list):
+        item_schema = schema.get("items")
+        if isinstance(item_schema, dict) and item_schema:
+            for idx, item in enumerate(value):
+                sub_path = f"{path}[{idx}]" if path else f"[{idx}]"
+                issues.extend(
+                    validate_param_value(item, item_schema, path=sub_path)
+                )
+    return issues
+
+
+def validate_tool_arguments(
+    args: Dict[str, Any],
+    func_name: str,
+    schema_index: Dict[str, Dict[str, Dict[str, Any]]],
+    *,
+    required: Optional[Sequence[str]] = None,
+) -> List[ParamValidationIssue]:
+    func_props = schema_index.get(func_name) or {}
+    issues: List[ParamValidationIssue] = []
+    if required:
+        for key in required:
+            if key not in args:
+                issues.append(
+                    ParamValidationIssue(key, "required parameter is missing")
+                )
+    for key, value in args.items():
+        pschema = func_props.get(key) or {}
+        if pschema:
+            issues.extend(validate_param_value(value, pschema, path=key))
+    return issues
+
+
+def format_issues_for_llm(
+    issues: Sequence[ParamValidationIssue],
+    *,
+    tool_name: str = "",
+) -> str:
+    return ToolArgValidationError(list(issues), tool_name=tool_name).to_llm_feedback()
+
+
+def assert_valid_tool_arguments(
+    args: Dict[str, Any],
+    func_name: str,
+    schema_index: Dict[str, Dict[str, Dict[str, Any]]],
+    *,
+    required: Optional[Sequence[str]] = None,
+) -> None:
+    issues = validate_tool_arguments(
+        args, func_name, schema_index, required=required
+    )
+    if issues:
+        raise ToolArgValidationError(issues, tool_name=func_name)

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/protocols/entml_stream/body.py

@@ -127,10 +127,10 @@ def _final_invoke_arguments_json(
 
 
 def _streaming_string_value(raw: str, *, is_complete: bool) -> str:
-    """与 ``parse_invoke_args`` 的 ``strip()`` 对齐，并避免 XML 换行导致非单调前缀。"""
+    """流式 string 参数：保留模型原文；未完成时仅去掉尾部未收齐的标签前缀。"""
     if is_complete:
-        return raw.strip()
-    return raw.lstrip().rstrip("\r\n")
+        return raw
+    return _strip_incomplete_markup_suffix(raw)
 
 
 def _parameter_json_fragment(
@@ -197,7 +197,7 @@ def _parse_bare_invoke_entries(body: str) -> List[Tuple[str, str, bool, Optional
         key = normalize_entml_name(match.group(1))
         if not key:
             continue
-        tagged.append((match.start(), key, (match.group(2) or "").strip(), True, None))
+        tagged.append((match.start(), key, match.group(2) or "", True, None))
     for match in BARE_INVOKE_CHILD_OPEN_RE.finditer(body):
         key = normalize_entml_name(match.group(1))
         if not key:
@@ -229,7 +229,7 @@ def _parse_direct_child_entries(body: str) -> List[Tuple[str, str, bool, Optiona
         key = normalize_entml_name(match.group(1))
         if not key or key.lower() in INVOKE_DIRECT_CHILD_SKIP:
             continue
-        tagged.append((match.start(), key, (match.group(2) or "").strip(), True, None))
+        tagged.append((match.start(), key, match.group(2) or "", True, None))
     for match in INVOKE_DIRECT_CHILD_OPEN_RE.finditer(gap_text):
         key = normalize_entml_name(match.group(1))
         if not key or key.lower() in INVOKE_DIRECT_CHILD_SKIP:
@@ -284,7 +284,7 @@ def _parse_parameter_entries(body: str) -> List[Tuple[str, str, bool, Optional[s
             for extra_key, extra_val in extra.items():
                 entries.append((extra_key, str(extra_val), True, None))
             break
-        raw = body[val_start:close].strip()
+        raw = body[val_start:close]
         raw, extra = split_mangled_json_param_tail(raw, param_name=key)
         entries.append((key, raw, True, type_hint))
         for extra_key, extra_val in extra.items():

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/protocols/entml_tool/fakemarkup.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import re
-from typing import Tuple
+from typing import List, Tuple
 
 from .comment import (
     leading_partial_tool_result_id_comment_len,
@@ -83,6 +83,10 @@ _TRAILING_ORPHAN_ENTML_CLOSE_RE = re.compile(
     r"(?:\n|\A)\s*</entml:?[a-z0-9_-]*>\s*$",
     re.IGNORECASE,
 )
+_ENTML_INVOKE_BLOCK_RE = re.compile(
+    r"<entml:invoke\b[^>]*>[\s\S]*?</entml:invoke>",
+    re.IGNORECASE,
+)
 
 
 def _strip_fake_entml_result_id_blocks(text: str) -> Tuple[str, bool]:
@@ -184,6 +188,30 @@ def _truncate_unclosed_fake_result_id_tail(text: str) -> Tuple[str, bool]:
     return text, found
 
 
+def _collapse_excess_blank_lines(text: str) -> str:
+    """压缩连续空行；``<entml:invoke>`` 块内原样保留（含 parameter 多行值）。"""
+    if not text:
+        return text
+    parts: List[Tuple[str, bool]] = []
+    i = 0
+    while i < len(text):
+        match = _ENTML_INVOKE_BLOCK_RE.search(text, i)
+        if not match:
+            parts.append((text[i:], False))
+            break
+        if match.start() > i:
+            parts.append((text[i : match.start()], False))
+        parts.append((match.group(0), True))
+        i = match.end()
+    out: List[str] = []
+    for chunk, protected in parts:
+        if protected:
+            out.append(chunk)
+        else:
+            out.append(re.sub(r"\n{3,}", "\n\n", chunk))
+    return "".join(out)
+
+
 def strip_fake_entml_structure_markup(content: str) -> Tuple[str, bool]:
     """batch：id result 整块 → 仅标签 → Tool Result ID 注释。"""
     if not content:
@@ -200,7 +228,7 @@ def strip_fake_entml_structure_markup(content: str) -> Tuple[str, bool]:
     found = found or hit
     text, hit = _strip_orphan_entml_close_leaks(text)
     found = found or hit
-    text = re.sub(r"\n{3,}", "\n\n", text)
+    text = _collapse_excess_blank_lines(text)
     return text, found
 
 

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/protocols/entml_tool/invoke.py

@@ -23,6 +23,7 @@ from ..entml_patterns.regex import (
     PARAMETERS_RE,
 )
 from ..entml_schema.mangled import split_mangled_json_param_tail
+from .fakemarkup import strip_fake_entml_structure_markup
 from .values import (
     _coerce_entml_arg_value,
     coerce_entml_arguments,
@@ -41,7 +42,7 @@ def _parse_direct_child_tags(
         key = normalize_entml_name(match.group(1))
         if not key or key.lower() in INVOKE_DIRECT_CHILD_SKIP or key in args:
             continue
-        raw = (match.group(2) or "").strip()
+        raw = match.group(2) or ""
         args[key] = coerce_entml_parameter_value(
             raw,
             func_props.get(key) or None,
@@ -58,7 +59,7 @@ def _parse_bare_invoke_children(
         key = normalize_entml_name(match.group(1))
         if not key or key in args:
             continue
-        raw = (match.group(2) or "").strip()
+        raw = match.group(2) or ""
         args[key] = coerce_entml_parameter_value(
             raw,
             func_props.get(key) or None,
@@ -93,7 +94,7 @@ def _fill_parameter_tag_args(
         if not pname:
             continue
         pname = normalize_entml_name(pname)
-        pval = (param_m.group(2) or "").strip()
+        pval = param_m.group(2) or ""
         pval, extra = split_mangled_json_param_tail(pval, param_name=pname)
         type_hint = extract_parameter_type_attr(attrs)
         pschema = func_props.get(pname) or {}
@@ -124,7 +125,7 @@ def parse_invoke_args(
     params_m = PARAMETERS_RE.search(body)
     if params_m:
         return _parse_parameters_block_args(
-            params_m.group(1).strip(), name, schema_index
+            params_m.group(1), name, schema_index
         )
     args: Dict[str, Any] = {}
     _fill_parameter_tag_args(body, args, func_props)
@@ -138,6 +139,8 @@ def parse_entml_tool_calls(
     tools: Optional[List[Dict[str, Any]]],
     schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]],
 ) -> List[Dict[str, Any]]:
+    if text:
+        text, _ = strip_fake_entml_structure_markup(text)
     tool_calls: List[Dict[str, Any]] = []
     known = resolve_known_tool_names(tools, schema_index)
     for _start, _end, attrs, body in iter_actionable_entml_invoke_blocks(

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/protocols/entml_tool/values.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 import json
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Sequence
 
 from echotools.exec.fncall.shared.coercion import (
     _coerce_param_value,
     _resolve_effective_type,
 )
+from echotools.exec.fncall.protocols.entml_schema.validate import (
+    assert_valid_tool_arguments,
+)
 
 _TYPE_HINT_TO_JSON_TYPE = {
     "str": "string",
@@ -61,17 +64,16 @@ def coerce_entml_parameter_value(
     if effective:
         return _coerce_param_value(raw, effective)
 
-    stripped = (raw or "").strip()
-    if not stripped:
+    if raw is None or raw == "":
         return ""
 
-    if stripped[0] in "{[":
+    if raw.lstrip().startswith(("{", "[")):
         try:
-            return json.loads(stripped)
+            return json.loads(raw)
         except json.JSONDecodeError:
-            return stripped
+            return raw
 
-    return stripped
+    return raw
 
 
 def effective_entml_param_json_type(
@@ -116,8 +118,11 @@ def coerce_entml_arguments(
     args: Dict[str, Any],
     func_name: str,
     schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]],
+    *,
+    strict: bool = False,
+    required: Optional[Sequence[str]] = None,
 ) -> Dict[str, Any]:
-    """对已解析参数字典按工具 schema 做逐项类型转换。"""
+    """对已解析参数字典按工具 schema 做逐项类型转换，可选 strict 校验。"""
     if not schema_index or not func_name:
         return args
     func_schema = schema_index.get(func_name) or {}
@@ -131,4 +136,8 @@ def coerce_entml_arguments(
             out[key] = _coerce_entml_arg_value(value, pschema)
         else:
             out[key] = value
+    if strict:
+        assert_valid_tool_arguments(
+            out, func_name, schema_index, required=required
+        )
     return out

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/shared/coercion.py

@@ -7,9 +7,13 @@
 from __future__ import annotations
 
 import json
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Sequence
 
 from echotools.base.logger.manager import get_logger
+from echotools.exec.fncall.protocols.entml_schema.validate import (
+    is_null_literal,
+    schema_allows_null,
+)
 
 logger = get_logger(__name__)
 
@@ -51,6 +55,24 @@ def _build_param_schema_index(
     return index
 
 
+def required_params_for_func(
+    tools: Optional[List[Dict[str, Any]]],
+    func_name: str,
+) -> List[str]:
+    if not tools or not func_name:
+        return []
+    for tool in tools:
+        fn: Dict[str, Any] = tool.get("function", tool)  # type: ignore[arg-type]
+        if (fn.get("name") or "") != func_name:
+            continue
+        params = fn.get("parameters") or {}
+        required = params.get("required")
+        if isinstance(required, list):
+            return [str(k) for k in required if k]
+        return []
+    return []
+
+
 def _resolve_effective_type(schema: Dict[str, Any]) -> Optional[str]:
     """从 JSON Schema 中解析出有效的单一类型字符串。"""
     if not schema:
@@ -254,17 +276,16 @@ def _coerce_param_value(raw: str, schema: Dict[str, Any]) -> Any:
     if not schema:
         return parsed
 
+    if schema_allows_null(schema) and is_null_literal(raw):
+        return None
+
     effective_type = _resolve_effective_type(schema)
 
     if effective_type is None:
         return parsed
 
     if effective_type == "string":
-        # string 字段保留原文；仅当整段是 JSON 字符串字面量 ("...") 时才解包
-        if len(stripped) >= 2 and stripped[0] == '"' and stripped[-1] == '"':
-            if isinstance(parsed, str):
-                return parsed
-        return stripped
+        return raw
 
     if effective_type == "integer":
         return _coerce_to_integer(stripped, parsed)

{echotools-2.4.1 → echotools-2.4.2}/src/echotools/exec/fncall/shared/entml_format.py

@@ -10,7 +10,6 @@ from echotools.exec.fncall.prompt.behavior_blocks import (
     format_function_calling_behavior,
     format_hard_constraint_restatement,
 )
-from echotools.exec.fncall.prompt.templates import _HISTORY_CLARIFY_EN
 from echotools.exec.fncall.protocols.entml_think.core import (
     build_entml_thinking_behavior_section,
     build_entml_thinking_meta_section,
@@ -18,6 +17,22 @@ from echotools.exec.fncall.protocols.entml_think.core import (
 
 _ENTML_NAMESPACE_RE = re.compile(r"(</?)entml:", re.IGNORECASE)
 
+_HISTORY_CLARIFY_EN = (
+    "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."
+)
+
 _ENTML_INSTRUCTION = """\
 In this environment you have access to a set of tools you can use to answer the user's question.
 You can invoke functions by writing a "<entml:invoke>" block like the following as part of your reply to the user:

{echotools-2.4.1 → echotools-2.4.2}/src/echotools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.4.1
+Version: 2.4.2
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Home-page: https://github.com/nichengfuben/echotools
 Author: nichengfuben
@@ -58,7 +58,7 @@ Requires-Dist: ruff>=0.4.0; extra == "dev"
 
 通用基础设施 SDK：配置、日志、事件、调度、插件、调用链，以及 **entml** LLM 工具调用协议与终端 Console UI。
 
-完全项目无关，兼容 Python 3.8–3.14。当前版本：**2.4.1**（详见 [CHANGELOG](docs/CHANGELOG.md)）。
+完全项目无关，兼容 Python 3.8–3.14。当前版本：**2.4.2**（详见 [CHANGELOG](docs/CHANGELOG.md)）。
 
 ## 安装