echotools 2.3.11__tar.gz → 2.3.13__tar.gz

{echotools-2.3.11 → echotools-2.3.13}/PKG-INFO

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

{echotools-2.3.11 → echotools-2.3.13}/pyproject.toml

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

{echotools-2.3.11 → echotools-2.3.13}/src/echotools/exec/fncall/prompt/history.py

@@ -50,7 +50,7 @@ _ENTML_PARAMETERS_RE = re.compile(
     re.DOTALL,
 )
 _ENTML_PARAM_RE = re.compile(
-    r'<entml:parameter\s+name="[^"]+"\s*>.*?</entml:parameter>',
+    r'<entml:parameter\s+name="[^"]+"[^>]*>.*?</entml:parameter>',
     re.DOTALL,
 )
 # 清理任意 entml:* 标签

{echotools-2.3.11 → echotools-2.3.13}/src/echotools/exec/fncall/protocols/entml.py

@@ -9,44 +9,35 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional, Tuple
 
-from echotools.exec.fncall.prompt.templates import (
-    _HISTORY_CLARIFY_EN,
-    _HISTORY_CLARIFY_ZH,
-)
+from echotools.exec.fncall.prompt.templates import _HISTORY_CLARIFY_EN
 from echotools.exec.fncall.protocols.entml_invoke import (
     format_entml_tool_calls,
     parse_entml_tool_calls,
 )
 from echotools.exec.fncall.protocols.entml_patterns import BLOCK_RE
 from echotools.exec.fncall.protocols.entml_thinking 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 normalize_tool_calls
 from echotools.exec.protocol.base import ToolProtocol
 
 _ENTML_INSTRUCTION = """\
-## Function Definitions
-
-All functions are defined inside a `<functions>` wrapper block. Each function is a JSON object inside a `<function>` tag containing `description`, `name`, and `parameters` (JSON Schema).
-
-**Function Invocation Syntax:**
-
-When calling tools, respond with ONLY the following XML block format:
+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:function_calls>" block like the following as part of your reply to the user:
 
 <entml:function_calls>
-<entml:invoke name="tool_name">
-<entml:parameter name="param_name">value</entml:parameter>
+<entml:invoke name="$FUNCTION_NAME">
+<entml:parameter name="$PARAMETER_NAME">$PARAMETER_VALUE</entml:parameter>
+...
+</entml:invoke>
+<entml:invoke name="$FUNCTION_NAME2">
+...
 </entml:invoke>
 </entml:function_calls>
 
-String and scalar parameters should be specified as-is, while lists and objects should use JSON format.
+String and scalar parameters should be specified as is, while lists and objects should use JSON format.
 
-Multiple invocations can be stacked inside one `<entml:function_calls>` block for parallel execution.
-
-## Function Call Instructions
-
-Answer the user's request using the relevant tool(s), if they are available. Check that all required parameters are provided or can reasonably be inferred from context. If there are no relevant tools or missing required parameter values, ask the user. If the user provides a specific value for a parameter (e.g., in quotes), use that value EXACTLY. Do NOT make up values for or ask about optional parameters.
-
-If you intend to call multiple tools and there are no dependencies between the calls, make all independent calls in the same function_calls block. Otherwise, wait for previous calls to finish to determine dependent values (do NOT use placeholders or guess missing parameters).
+Here are the functions available in JSONSchema format:
 """
 
 
@@ -68,7 +59,7 @@ def format_entml_conversation_history(
 def format_entml_current_user_message(message: str) -> str:
     """将当前用户消息包裹为 <entml:current_user_message> 块。"""
     text = (message or "").strip()
-    return f"<entml:current_user_message>\n{text}\n</entml:current_user_message>"
+    return f"<entml:current_user_message>\n{text}\n</current_user_message>"
 
 
 class EntmlProtocol(ToolProtocol):
@@ -84,6 +75,10 @@ class EntmlProtocol(ToolProtocol):
     def get_trigger_tags(self) -> List[str]:
         return [self._TRIGGER]
 
+    @staticmethod
+    def format_tool_descs(tools: List[Dict[str, Any]]) -> str:
+        return format_entml_tool_descs(tools)
+
     def render_prompt(
         self,
         tool_descs: str,
@@ -94,11 +89,11 @@ class EntmlProtocol(ToolProtocol):
         current_user_message: str = "",
         protocol_options: Optional[Dict[str, Any]] = None,
     ) -> str:
-        sections: List[str] = [_ENTML_INSTRUCTION]
+        sections: List[str] = [_ENTML_INSTRUCTION + tool_descs]
+
         thinking_section = build_entml_thinking_section(protocol_options)
         if thinking_section:
             sections.append(thinking_section)
-        sections.append("<functions>\n" + tool_descs + "\n</functions>")
 
         if user_system_prompt and user_system_prompt.strip():
             sections.append(
@@ -106,9 +101,8 @@ class EntmlProtocol(ToolProtocol):
             )
 
         if history_text:
-            clarify = _HISTORY_CLARIFY_ZH if lang == "zh" else _HISTORY_CLARIFY_EN
             sections.append(
-                format_entml_conversation_history(history_text, clarify)
+                format_entml_conversation_history(history_text, _HISTORY_CLARIFY_EN)
             )
 
         if loop_warning:

{echotools-2.3.11 → echotools-2.3.13}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -8,6 +8,7 @@ from .entml_patterns import (
     INVOKE_RE,
     PARAM_RE,
     PARAMETERS_RE,
+    extract_parameter_type_attr,
     parse_sub_tags,
 )
 from .entml_values import coerce_entml_arguments, coerce_entml_parameter_value
@@ -37,9 +38,15 @@ def parse_invoke_args(
     args: Dict[str, Any] = {}
     for param_m in PARAM_RE.finditer(body):
         pname = param_m.group(1).strip()
-        pval = param_m.group(2)
+        attrs = param_m.group(2) or ""
+        pval = param_m.group(3)
+        type_hint = extract_parameter_type_attr(attrs)
         pschema = func_props.get(pname) or {}
-        args[pname] = coerce_entml_parameter_value(pval, pschema or None)
+        args[pname] = coerce_entml_parameter_value(
+            pval,
+            pschema or None,
+            type_hint=type_hint if not pschema else None,
+        )
 
     return coerce_entml_arguments(args, name, schema_index)
 

{echotools-2.3.11 → echotools-2.3.13}/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -14,9 +14,10 @@ INVOKE_RE = re.compile(
     re.DOTALL,
 )
 PARAM_RE = re.compile(
-    r'<entml:parameter\s+name="([^"]+)">\s*([\s\S]*?)\s*</entml:parameter>',
+    r'<entml:parameter\s+name="([^"]+)"([^>]*)>\s*([\s\S]*?)\s*</entml:parameter>',
     re.DOTALL,
 )
+_PARAM_TYPE_ATTR_RE = re.compile(r'\btype="([^"]+)"')
 PARAMETERS_RE = re.compile(
     r'<entml:parameters>([\s\S]*?)</entml:parameters>',
     re.DOTALL,
@@ -27,6 +28,14 @@ SUB_TAG_RE = re.compile(
 )
 
 
+def extract_parameter_type_attr(attrs: str) -> Optional[str]:
+    """从 parameter 开标签属性中提取 type=\"...\"。"""
+    match = _PARAM_TYPE_ATTR_RE.search(attrs or "")
+    if not match:
+        return None
+    return match.group(1).strip()
+
+
 def parse_sub_tags(
     content: str,
     schema_index: Optional[Dict[str, Any]] = None,

{echotools-2.3.11 → echotools-2.3.13}/src/echotools/exec/fncall/protocols/entml_thinking.py

@@ -14,7 +14,7 @@ def build_entml_thinking_section(
     if thinking_mode is None and max_thinking_length is None:
         return ""
 
-    lines = ["## Thinking", ""]
+    lines: list[str] = []
     if thinking_mode is not None:
         mode = str(thinking_mode).strip()
         if mode:
@@ -30,12 +30,24 @@ def build_entml_thinking_section(
             [
                 "",
                 "If the thinking_mode is interleaved or auto, then after function "
-                "results you should strongly consider outputting a thinking block "
-                "before continuing:",
+                "results you should strongly consider outputting a thinking block. "
+                "Here is an example:",
+                "",
+                "<entml:function_calls>",
+                "...",
+                "</entml:function_calls>",
+                "",
+                "<function_results>",
+                "...",
+                "</function_results>",
                 "",
                 "<entml:thinking>",
-                "...thinking about results...",
+                "...thinking about results",
                 "</entml:thinking>",
+                "Whenever you have the result of a function call, think carefully "
+                "about whether an `<entml:thinking>` `</entml:thinking>` block "
+                "would be appropriate and strongly prefer to output a thinking "
+                "block if you are uncertain.",
             ]
         )
 

echotools-2.3.13/src/echotools/exec/fncall/protocols/entml_tools.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Dict, List, Mapping
+
+__all__ = ["format_entml_tool_descs"]
+
+_SCHEMA_KEY_ORDER = (
+    "description",
+    "type",
+    "enum",
+    "items",
+    "properties",
+    "required",
+    "minItems",
+    "maxItems",
+    "minimum",
+    "maximum",
+    "default",
+    "additionalProperties",
+    "oneOf",
+    "anyOf",
+    "allOf",
+)
+
+_DESC_LINE_RE = re.compile(
+    r'^(\s*)"description": "((?:[^"\\]|\\.)*)"(,?)$',
+    re.MULTILINE,
+)
+
+
+def _sort_schema_keys(node: Any) -> Any:
+    """递归整理 JSON Schema 字段顺序（properties 的键名保持原序）。"""
+    if isinstance(node, list):
+        return [_sort_schema_keys(item) for item in node]
+    if not isinstance(node, dict):
+        return node
+
+    ordered_keys = [key for key in _SCHEMA_KEY_ORDER if key in node]
+    remaining_keys = sorted(key for key in node if key not in _SCHEMA_KEY_ORDER)
+    out: Dict[str, Any] = {}
+    for key in ordered_keys + remaining_keys:
+        value = node[key]
+        if key == "properties" and isinstance(value, Mapping):
+            out[key] = {
+                prop_name: _sort_schema_keys(prop_schema)
+                for prop_name, prop_schema in value.items()
+            }
+        else:
+            out[key] = _sort_schema_keys(value)
+    return out
+
+
+def _normalize_parameters(params: Any) -> Dict[str, Any]:
+    if not isinstance(params, dict):
+        return {"type": "object", "properties": {}}
+    normalized = dict(params)
+    normalized.setdefault("type", "object")
+    normalized.setdefault("properties", {})
+    return _sort_schema_keys(normalized)
+
+
+def _escape_multiline_description_line(line: str) -> str:
+    return line.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def _expand_description_multiline(json_text: str) -> str:
+    """将 description 中的 \\n 展开为可读多行（对齐 antml 示范排版）。"""
+
+    def _repl(match: re.Match[str]) -> str:
+        indent, escaped, comma = match.groups()
+        decoded = json.loads('"' + escaped + '"')
+        if "\n" not in decoded:
+            return match.group(0)
+        lines = decoded.split("\n")
+        first = _escape_multiline_description_line(lines[0])
+        if len(lines) == 1:
+            return f'{indent}"description": "{first}"{comma}'
+        body = first + "\n" + "\n".join(
+            _escape_multiline_description_line(line) for line in lines[1:]
+        )
+        return f'{indent}"description": "{body}"{comma}'
+
+    return _DESC_LINE_RE.sub(_repl, json_text)
+
+
+def _format_tool_json(payload: Mapping[str, Any]) -> str:
+    sorted_payload = _sort_schema_keys(dict(payload))
+    body = json.dumps(sorted_payload, ensure_ascii=False, indent=2)
+    return _expand_description_multiline(body)
+
+
+def format_entml_tool_descs(tools: List[Dict[str, Any]]) -> str:
+    """将工具列表格式化为 **name** + JSON Schema 代码块（对齐 entml/antml 示范）。"""
+    if not tools:
+        return ""
+
+    blocks: List[str] = []
+    for tool in tools:
+        fn = tool.get("function", tool)
+        name = str(fn.get("name") or "unknown")
+        payload = {
+            "description": fn.get("description") or "",
+            "name": name,
+            "parameters": _normalize_parameters(fn.get("parameters")),
+        }
+        body = _format_tool_json(payload)
+        blocks.append(f"**{name}**\n\n```json\n{body}\n```")
+    return "\n\n".join(blocks)

{echotools-2.3.11 → echotools-2.3.13}/src/echotools/exec/fncall/protocols/entml_values.py

@@ -5,15 +5,46 @@ from typing import Any, Dict, Optional
 
 from echotools.exec.fncall.shared.coercion import _coerce_param_value
 
+_TYPE_HINT_TO_JSON_TYPE = {
+    "str": "string",
+    "string": "string",
+    "int": "integer",
+    "integer": "integer",
+    "float": "number",
+    "number": "number",
+    "double": "number",
+    "bool": "boolean",
+    "boolean": "boolean",
+    "array": "array",
+    "list": "array",
+    "object": "object",
+    "dict": "object",
+}
+
+
+def _schema_from_type_hint(type_hint: str) -> Optional[Dict[str, Any]]:
+    json_type = _TYPE_HINT_TO_JSON_TYPE.get((type_hint or "").strip().lower())
+    if not json_type:
+        return None
+    schema: Dict[str, Any] = {"type": json_type}
+    if json_type == "array":
+        schema["items"] = {}
+    return schema
+
 
 def coerce_entml_parameter_value(
     raw: str,
     schema: Optional[Dict[str, Any]] = None,
+    type_hint: Optional[str] = None,
 ) -> Any:
-    """将 entml 参数文本按 schema（若有）或边界规则转为 Python 值。"""
+    """将 entml 参数文本按 schema、type 属性或默认 str 规则转为 Python 值。"""
     if schema:
         return _coerce_param_value(raw, schema)
 
+    hint_schema = _schema_from_type_hint(type_hint) if type_hint else None
+    if hint_schema:
+        return _coerce_param_value(raw, hint_schema)
+
     stripped = (raw or "").strip()
     if not stripped:
         return ""
@@ -22,34 +53,9 @@ def coerce_entml_parameter_value(
         try:
             return json.loads(stripped)
         except json.JSONDecodeError:
-            return raw
-
-    lowered = stripped.lower()
-    if lowered == "null":
-        return None
-    if lowered == "true":
-        return True
-    if lowered == "false":
-        return False
-
-    if stripped.isdigit() or (
-        stripped.startswith("-") and stripped[1:].isdigit()
-    ):
-        try:
-            return int(stripped)
-        except ValueError:
-            pass
-
-    try:
-        if any(ch in stripped for ch in ".eE"):
-            fval = float(stripped)
-            if fval.is_integer() and "." not in stripped and "e" not in lowered:
-                return int(fval)
-            return fval
-    except ValueError:
-        pass
+            return stripped
 
-    return raw
+    return stripped
 
 
 def coerce_entml_arguments(

{echotools-2.3.11 → echotools-2.3.13}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.11 → echotools-2.3.13}/src/echotools.egg-info/SOURCES.txt

@@ -58,6 +58,7 @@ 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_thinking.py
+src/echotools/exec/fncall/protocols/entml_tools.py
 src/echotools/exec/fncall/protocols/entml_values.py
 src/echotools/exec/fncall/shared/__init__.py
 src/echotools/exec/fncall/shared/coercion.py
@@ -149,6 +150,7 @@ src/tests/test_dispatch.py
 src/tests/test_dispatch_extended.py
 src/tests/test_dispatch_race.py
 src/tests/test_entml_protocol.py
+src/tests/test_entml_tools.py
 src/tests/test_errors.py
 src/tests/test_errors_common.py
 src/tests/test_events.py

{echotools-2.3.11 → echotools-2.3.13}/src/tests/test_entml_protocol.py

@@ -28,7 +28,7 @@ def test_inject_no_tools_entml_tags() -> None:
     result = inject_fncall(msgs, [], proto)
     assert len(result) == 1
     content = result[0]["content"]
-    assert "<entml:current_user_message>\nhi\n</entml:current_user_message>" in content
+    assert "<entml:current_user_message>\nhi\n</current_user_message>" in content
     assert "<entml:thinking_mode>" not in content
     assert "<entml:max_thinking_length>" not in content
 
@@ -88,7 +88,29 @@ def test_inject_with_history_entml_tags() -> None:
     out = inject_fncall(msgs, tools, proto)
     content = out[0]["content"]
     assert "<entml:conversation_history>" in content
-    assert "<entml:current_user_message>\nnew\n</entml:current_user_message>" in content
+    assert "<entml:current_user_message>\nnew\n</current_user_message>" in content
+
+
+def test_entml_history_clarify_always_english() -> None:
+    proto = get_protocol("entml")
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "search",
+                "description": "Search",
+                "parameters": {"type": "object", "properties": {}},
+            },
+        }
+    ]
+    msgs = [
+        {"role": "user", "content": "old"},
+        {"role": "assistant", "content": "ok"},
+        {"role": "user", "content": "new"},
+    ]
+    content = inject_fncall(msgs, tools, proto, lang="zh")[0]["content"]
+    assert "The following is a transcript of completed interactions." in content
+    assert "以下是已完成的交互记录" not in content
 
 
 @pytest.mark.parametrize(
@@ -98,21 +120,27 @@ def test_inject_with_history_entml_tags() -> None:
         ("false", {"type": "boolean"}, False),
         ("42", {"type": "integer"}, 42),
         ("3.14", {"type": "number"}, 3.14),
-        ("null", None, None),
+        ("null", None, "null"),
         ('["a","b"]', {"type": "array", "items": {"type": "string"}}, ["a", "b"]),
+        ('["a","b"]', None, ["a", "b"]),
         ("plain text", {"type": "string"}, "plain text"),
         ("plain text", None, "plain text"),
+        ("42", None, "42"),
+        ("42", "int", 42),
+        ("true", None, "true"),
+        ("true", "bool", True),
     ],
 )
 def test_coerce_entml_parameter_value(raw, schema, expected) -> None:
-    assert coerce_entml_parameter_value(raw, schema) == expected
+    if isinstance(schema, str):
+        assert coerce_entml_parameter_value(raw, type_hint=schema) == expected
+    else:
+        assert coerce_entml_parameter_value(raw, schema) == expected
 
 
 def test_entml_instruction_matches_spec_format() -> None:
-    """示范格式：<entml:function_calls> + <entml:invoke> + <entml:parameter>."""
+    """示范格式：环境说明 + JSONSchema 工具块 + entml 调用标签。"""
     proto = get_protocol("entml")
-    from echotools.exec.fncall.shared.normalization import format_tool_descs
-
     tools = [
         {
             "type": "function",
@@ -134,17 +162,28 @@ def test_entml_instruction_matches_spec_format() -> None:
         }
     ]
     prompt = proto.render_prompt(
-        tool_descs=format_tool_descs(tools),
+        tool_descs=proto.format_tool_descs(tools),
         lang="en",
         current_user_message="pick one",
+        protocol_options={
+            "thinking_mode": "interleaved",
+            "max_thinking_length": 22000,
+        },
     )
+    assert "In this environment you have access to a set of tools" in prompt
+    assert "Here are the functions available in JSONSchema format:" in prompt
+    assert "**ask_user_input_v0**" in prompt
+    assert '"name": "ask_user_input_v0"' in prompt
     assert "<entml:function_calls>" in prompt
-    assert '<entml:invoke name="' in prompt
-    assert '<entml:parameter name="' in prompt
-    assert "String and scalar parameters should be specified as-is" in prompt
+    assert '<entml:invoke name="$FUNCTION_NAME">' in prompt
+    assert '<entml:parameter name="$PARAMETER_NAME">' in prompt
+    assert "String and scalar parameters should be specified as is" in prompt
+    assert "<entml:thinking_mode>interleaved</entml:thinking_mode>" in prompt
+    assert "<entml:max_thinking_length>22000</entml:max_thinking_length>" in prompt
+    assert "<function_results>" in prompt
     assert "<entml:conversation_history>" not in prompt
     assert "<entml:history>" not in prompt
-    assert "<entml:thinking_mode>" not in prompt
+    assert "<functions>" not in prompt
 
 
 def test_entml_roundtrip_parameter_format() -> None:
@@ -172,10 +211,90 @@ def test_entml_roundtrip_parameter_format() -> None:
     parsed = parse_entml_tool_calls(rendered, None, None)
     args = json.loads(parsed[0]["function"]["arguments"])
     assert args["query"] == "hello"
-    assert args["limit"] == 3
+    assert args["limit"] == "3"
     assert args["tags"] == ["a", "b"]
 
 
+def test_entml_parse_parameter_type_attribute() -> None:
+    """模型可能在 parameter 标签上附带 type 属性（如 type=\"str\"）。"""
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_weather",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "city": {"type": "string"},
+                        "units": {"type": "string"},
+                    },
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "search_web",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {"type": "string"},
+                        "limit": {"type": "integer"},
+                    },
+                },
+            },
+        },
+    ]
+    schema_index = _build_param_schema_index(tools)
+    sample = (
+        '<entml:function_calls>'
+        '<entml:invoke name="get_weather">'
+        '<entml:parameter name="city" type="str">Shanghai</entml:parameter>'
+        '<entml:parameter name="units" type="str">celsius</entml:parameter>'
+        "</entml:invoke>"
+        '<entml:invoke name="search_web">'
+        '<entml:parameter name="query" type="str">上海 明天 降雨 2026-07-23</entml:parameter>'
+        '<entml:parameter name="limit" type="int">3</entml:parameter>'
+        "</entml:invoke>"
+        "</entml:function_calls>"
+    )
+    calls = parse_entml_tool_calls(sample, tools, schema_index)
+    assert len(calls) == 2
+
+    weather = json.loads(calls[0]["function"]["arguments"])
+    assert weather == {"city": "Shanghai", "units": "celsius"}
+
+    search = json.loads(calls[1]["function"]["arguments"])
+    assert search["query"] == "上海 明天 降雨 2026-07-23"
+    assert search["limit"] == 3
+    assert isinstance(search["limit"], int)
+
+
+def test_entml_parse_parameter_default_str_without_type_attr() -> None:
+    """无 type= 且无 schema 时，标量默认按 str 处理。"""
+    sample = (
+        '<entml:function_calls><entml:invoke name="echo">'
+        '<entml:parameter name="count">42</entml:parameter>'
+        '<entml:parameter name="flag">true</entml:parameter>'
+        "</entml:invoke></entml:function_calls>"
+    )
+    calls = parse_entml_tool_calls(sample, None, None)
+    args = json.loads(calls[0]["function"]["arguments"])
+    assert args == {"count": "42", "flag": "true"}
+
+
+def test_entml_parse_parameter_type_hint_without_schema() -> None:
+    sample = (
+        '<entml:function_calls><entml:invoke name="echo">'
+        '<entml:parameter name="count" type="int">42</entml:parameter>'
+        '<entml:parameter name="flag" type="bool">true</entml:parameter>'
+        "</entml:invoke></entml:function_calls>"
+    )
+    calls = parse_entml_tool_calls(sample, None, None)
+    args = json.loads(calls[0]["function"]["arguments"])
+    assert args == {"count": 42, "flag": True}
+
+
 def test_entml_parse_schema_coercion() -> None:
     tools = [
         {