echotools 2.3.12__tar.gz → 2.3.14__tar.gz

{echotools-2.3.12 → echotools-2.3.14}/PKG-INFO

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

{echotools-2.3.12 → echotools-2.3.14}/pyproject.toml

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

{echotools-2.3.12 → echotools-2.3.14}/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.12 → echotools-2.3.14}/src/echotools/exec/fncall/protocols/entml.py

@@ -2,7 +2,7 @@
 
 - 工具调用：<entml:function_calls> / <entml:invoke> / <entml:parameter>
 - 对话历史：<entml:conversation_history>
-- 当前用户消息：<entml:current_user_message>
+- 当前用户消息：<current_user_message>
 """
 
 from __future__ import annotations
@@ -57,9 +57,9 @@ def format_entml_conversation_history(
 
 
 def format_entml_current_user_message(message: str) -> str:
-    """将当前用户消息包裹为 <entml:current_user_message> 块。"""
+    """将当前用户消息包裹为 <current_user_message> 块。"""
     text = (message or "").strip()
-    return f"<entml:current_user_message>\n{text}\n</entml:current_user_message>"
+    return f"<current_user_message>\n{text}\n</current_user_message>"
 
 
 class EntmlProtocol(ToolProtocol):

{echotools-2.3.12 → echotools-2.3.14}/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.12 → echotools-2.3.14}/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.12 → echotools-2.3.14}/src/echotools/exec/fncall/protocols/entml_thinking.py

@@ -41,13 +41,12 @@ def build_entml_thinking_section(
                 "...",
                 "</function_results>",
                 "",
-                "<entml:thinking>",
+                "<thinking>",
                 "...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.",
+                "</thinking>",
+                "At the very start of your response, think carefully about whether "
+                "a `<thinking>` `</thinking>` block would be appropriate and "
+                "strongly prefer to output a thinking block if you are uncertain.",
             ]
         )
 

echotools-2.3.14/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.12 → echotools-2.3.14}/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.12 → echotools-2.3.14}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.12 → echotools-2.3.14}/src/echotools.egg-info/SOURCES.txt

@@ -150,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.12 → echotools-2.3.14}/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 "<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
 
@@ -60,7 +60,9 @@ def test_inject_with_thinking_options_only_when_declared() -> None:
     )[0]["content"]
     assert "<entml:thinking_mode>interleaved</entml:thinking_mode>" in with_opts
     assert "<entml:max_thinking_length>22000</entml:max_thinking_length>" in with_opts
-    assert "<entml:thinking>" in with_opts
+    assert "<thinking>" in with_opts
+    assert "At the very start of your response" in with_opts
+    assert "<entml:thinking>" not in with_opts
 
 
 def test_build_entml_thinking_section_empty_without_options() -> None:
@@ -88,7 +90,7 @@ 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 "<current_user_message>\nnew\n</current_user_message>" in content
 
 
 def test_entml_history_clarify_always_english() -> None:
@@ -120,14 +122,22 @@ def test_entml_history_clarify_always_english() -> 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:
@@ -203,10 +213,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 = [
         {

echotools-2.3.14/src/tests/test_entml_tools.py

@@ -0,0 +1,77 @@
+from echotools.exec.fncall.protocols.entml_tools import format_entml_tool_descs
+
+ASK_USER_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "ask_user_input_v0",
+        "description": (
+            "USE THIS TOOL WHENEVER YOU HAVE A QUESTION FOR THE USER.\n\n"
+            "USE THIS TOOL WHEN:\n"
+            "- User asks a question with 2-10 reasonable answers"
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "questions": {
+                    "items": {
+                        "properties": {
+                            "options": {
+                                "items": {"type": "string"},
+                                "maxItems": 4,
+                                "minItems": 2,
+                                "type": "array",
+                            },
+                            "question": {"type": "string"},
+                            "type": {
+                                "default": "single_select",
+                                "enum": [
+                                    "single_select",
+                                    "multi_select",
+                                    "rank_priorities",
+                                ],
+                                "type": "string",
+                            },
+                        },
+                        "required": ["question", "options"],
+                        "type": "object",
+                    },
+                    "maxItems": 3,
+                    "minItems": 1,
+                    "type": "array",
+                    "description": "1-3 questions to ask the user",
+                }
+            },
+            "required": ["questions"],
+        },
+    },
+}
+
+
+def test_entml_tool_descs_include_schema_types_and_required() -> None:
+    out = format_entml_tool_descs([ASK_USER_TOOL])
+    assert "**ask_user_input_v0**" in out
+    assert '"type": "object"' in out
+    assert '"type": "array"' in out
+    assert '"type": "string"' in out
+    assert '"enum":' in out
+    assert '"required":' in out
+    assert '"minItems":' in out
+    assert '"maxItems":' in out
+    assert '"default": "single_select"' in out
+
+
+def test_entml_tool_descs_expand_multiline_description() -> None:
+    out = format_entml_tool_descs([ASK_USER_TOOL])
+    assert "USE THIS TOOL WHENEVER YOU HAVE A QUESTION FOR THE USER.\n\n" in out
+    assert "USE THIS TOOL WHEN:\n" in out
+    assert "- User asks a question with 2-10 reasonable answers" in out
+    assert "\\nUSE THIS TOOL WHEN" not in out
+
+
+def test_entml_tool_descs_schema_key_order() -> None:
+    out = format_entml_tool_descs([ASK_USER_TOOL])
+    desc_pos = out.index('"description":')
+    type_pos = out.index('"type": "object"', desc_pos)
+    props_pos = out.index('"properties":', type_pos)
+    required_pos = out.index('"required":', props_pos)
+    assert desc_pos < type_pos < props_pos < required_pos

{echotools-2.3.12 → echotools-2.3.14}/src/tests/test_protocols.py

@@ -22,4 +22,4 @@ def test_inject_no_tools() -> None:
     result = inject_fncall(msgs, [], proto)
     assert len(result) == 1
     assert result[0]["role"] == "user"
-    assert "<entml:current_user_message>\nhi\n</entml:current_user_message>" in result[0]["content"]
+    assert "<current_user_message>\nhi\n</current_user_message>" in result[0]["content"]

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

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Any, Dict, List
-
-__all__ = ["format_entml_tool_descs"]
-
-
-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": fn.get("parameters")
-            or {"type": "object", "properties": {}},
-        }
-        body = json.dumps(payload, ensure_ascii=False, indent=2)
-        blocks.append(f"**{name}**\n\n```json\n{body}\n```")
-    return "\n\n".join(blocks)