echotools 1.0.36__tar.gz → 2.0.0__tar.gz

{echotools-1.0.36 → echotools-2.0.0}/PKG-INFO

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

{echotools-1.0.36 → echotools-2.0.0}/pyproject.toml

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

echotools-2.0.0/src/echotools/fncall/protocols/__init__.py

@@ -0,0 +1,14 @@
+"""协议注册 — echotools 仅内置 entml 标记语言。"""
+
+from echotools.protocol.base import register_protocol
+
+
+def _register_all() -> None:
+    from echotools.fncall.protocols.entml import EntmlProtocol
+
+    register_protocol(EntmlProtocol())
+
+
+_register_all()
+
+__all__ = ["_register_all"]

echotools-1.0.36/src/echotools/fncall/protocols/antml.py → echotools-2.0.0/src/echotools/fncall/protocols/entml.py

@@ -1,7 +1,7 @@
-"""Anthropic ML (antml) 协议实现。
+"""Entropy ML (entml) (entml) 协议实现。
 
-使用 <antml:function_calls> 作为触发标记，
-<antml:invoke name="..."> 作为调用格式。
+使用 <entml:function_calls> 作为触发标记，
+<entml:invoke name="..."> 作为调用格式。
 """
 
 from __future__ import annotations
@@ -36,13 +36,13 @@ All functions are defined inside a `<functions>` wrapper block. Each function is
 
 When calling tools, respond with ONLY the following XML block format:
 
-<antml:function_calls>
-<antml:invoke name="tool_name">
-<antml:parameters>{"param_name": "value"}</antml:parameters>
-</antml:invoke>
-</antml:function_calls>
+<entml:function_calls>
+<entml:invoke name="tool_name">
+<entml:parameters>{"param_name": "value"}</entml:parameters>
+</entml:invoke>
+</entml:function_calls>
 
-Multiple invocations can be stacked inside one `<antml:function_calls>` block for parallel execution.
+Multiple invocations can be stacked inside one `<entml:function_calls>` block for parallel execution.
 
 ## Function Call Instructions
 
@@ -58,40 +58,40 @@ If you intend to call multiple tools and there are no dependencies between the c
 # ---------------------------------------------------------------------------
 
 _BLOCK_RE = re.compile(
-    r"<antml:function_calls\b[^>]*>([\s\S]*?)</antml:function_calls>",
+    r"<entml:function_calls\b[^>]*>([\s\S]*?)</entml:function_calls>",
     re.DOTALL,
 )
 _INVOKE_RE = re.compile(
-    r'<antml:invoke\s+name="([^"]+)">\s*([\s\S]*?)\s*</antml:invoke>',
+    r'<entml:invoke\s+name="([^"]+)">\s*([\s\S]*?)\s*</entml:invoke>',
     re.DOTALL,
 )
 _PARAM_RE = re.compile(
-    r'<antml:parameter\s+name="([^"]+)">\s*([\s\S]*?)\s*</antml:parameter>',
+    r'<entml:parameter\s+name="([^"]+)">\s*([\s\S]*?)\s*</entml:parameter>',
     re.DOTALL,
 )
 _PARAMETERS_RE = re.compile(
-    r'<antml:parameters>([\s\S]*?)</antml:parameters>',
+    r'<entml:parameters>([\s\S]*?)</entml:parameters>',
     re.DOTALL,
 )
 
 # ---------------------------------------------------------------------------
-# Antml 协议
+# Entml 协议
 # ---------------------------------------------------------------------------
 
 
-class AntmlProtocol(ToolProtocol):
-    """Anthropic ML 格式工具调用协议适配器。
+class EntmlProtocol(ToolProtocol):
+    """Entropy ML (entml) 格式工具调用协议适配器。
 
-    使用 <antml:function_calls><antml:invoke name="...">...</antml:invoke>
+    使用 <entml:function_calls><entml:invoke name="...">...</entml:invoke>
     作为触发标记和调用格式。
     """
 
     @property
     def id(self) -> str:
-        return "antml"
+        return "entml"
 
-    _TRIGGER = "<antml:function_calls>"
-    _END_TAG = "</antml:function_calls>"
+    _TRIGGER = "<entml:function_calls>"
+    _END_TAG = "</entml:function_calls>"
 
     def get_trigger_tags(self) -> List[str]:
         return [self._TRIGGER]
@@ -134,13 +134,13 @@ class AntmlProtocol(ToolProtocol):
 
         return prompt
 
-    _TRIGGER_PREFIX = "<antml:function_calls"
+    _TRIGGER_PREFIX = "<entml:function_calls"
 
     def detect_start(self, buffer: str) -> Tuple[bool, int]:
-        """检测 buffer 中是否包含 ``<antml:function_calls...>`` 触发标记。
+        """检测 buffer 中是否包含 ``<entml:function_calls...>`` 触发标记。
 
-        容忍变体（如 ``<antml:function_calls >`` 或带属性），只要前缀
-        ``<antml:function_calls`` 后跟任意字符并以 ``>`` 闭合即视为触发。
+        容忍变体（如 ``<entml:function_calls >`` 或带属性），只要前缀
+        ``<entml:function_calls`` 后跟任意字符并以 ``>`` 闭合即视为触发。
         """
         pos = buffer.find(self._TRIGGER_PREFIX)
         if pos < 0:
@@ -171,10 +171,10 @@ class AntmlProtocol(ToolProtocol):
                 name = invoke_m.group(1).strip()
                 body = invoke_m.group(2)
 
-                # Extract parameters - support both <antml:parameter> and <antml:parameters>
+                # Extract parameters - support both <entml:parameter> and <entml:parameters>
                 args: Dict[str, Any] = {}
 
-                # Try <antml:parameters>{json}</antml:parameters> format first
+                # Try <entml:parameters>{json}</entml:parameters> format first
                 params_m = _PARAMETERS_RE.search(body)
                 if params_m:
                     params_json = params_m.group(1).strip()
@@ -183,7 +183,7 @@ class AntmlProtocol(ToolProtocol):
                     except json.JSONDecodeError:
                         args = {"value": params_json}
                 else:
-                    # Try <antml:parameter name="...">value</antml:parameter> format
+                    # Try <entml:parameter name="...">value</entml:parameter> format
                     for param_m in _PARAM_RE.finditer(body):
                         pname = param_m.group(1).strip()
                         pval = param_m.group(2).strip()
@@ -220,19 +220,19 @@ class AntmlProtocol(ToolProtocol):
         fragment: str,
         tools: Optional[List[Dict[str, Any]]] = None,
     ) -> List[Dict[str, Any]]:
-        """将已知的完整 antml 片段直接解析为 tool_calls 列表。"""
+        """将已知的完整 entml 片段直接解析为 tool_calls 列表。"""
         _, tool_calls = self.parse(fragment, tools)
         return tool_calls
 
     def clean_tags(self, content: str) -> str:
-        """从响应文本中移除 <antml:function_calls> 标签残留。"""
+        """从响应文本中移除 <entml:function_calls> 标签残留。"""
         return _BLOCK_RE.sub("", content).strip()
 
     def format_assistant_tool_calls(
         self,
         tool_calls: List[Dict[str, Any]],
     ) -> str:
-        """将 tool_call 对象列表渲染为 antml 格式。"""
+        """将 tool_call 对象列表渲染为 entml 格式。"""
         if not tool_calls:
             return ""
 
@@ -242,12 +242,12 @@ class AntmlProtocol(ToolProtocol):
             name = fn.get("name", "")
             args = fn.get("arguments", "{}")
             parts.append(
-                f'<antml:invoke name="{name}">'
-                f"<antml:parameters>{args}</antml:parameters>"
-                f"</antml:invoke>"
+                f'<entml:invoke name="{name}">'
+                f"<entml:parameters>{args}</entml:parameters>"
+                f"</entml:invoke>"
             )
-        return f"<antml:function_calls>{''.join(parts)}</antml:function_calls>"
+        return f"<entml:function_calls>{''.join(parts)}</entml:function_calls>"
 
     def supports_streaming(self) -> bool:
-        """antml 协议支持流式检测。"""
+        """entml 协议支持流式检测。"""
         return True

{echotools-1.0.36 → echotools-2.0.0}/src/echotools/fncall/registry.py

@@ -20,19 +20,28 @@ _registered = False
 _mapping_logged: set = set()
 
 
+_custom_factory = None
+
+
+def set_custom_protocol_factory(factory) -> None:
+    """由 Provider-Fncall-Util 等插件注入 custom 协议工厂。"""
+    global _custom_factory
+    _custom_factory = factory
+
+
 def _get_custom_protocol(
     prompt_en: str = "", prompt_zh: str = ""
 ) -> ToolProtocol:
-    """获取或创建 custom 协议。"""
+    """获取或创建 custom 协议（由 fncall 插件提供）。"""
     global _custom_instance
     if _custom_instance is not None:
         return _custom_instance
-    from echotools.fncall.protocols.custom import CustomProtocol
-
-    _custom_instance = CustomProtocol(
-        prompt_en=prompt_en, prompt_zh=prompt_zh
+    if _custom_factory is not None:
+        _custom_instance = _custom_factory(prompt_en, prompt_zh)
+        return _custom_instance
+    raise ValueError(
+        "custom 协议需要 Provider-Fncall-Util 插件；请安装并启用 fncall 插件"
     )
-    return _custom_instance
 
 
 def _ensure_registered() -> None:
@@ -49,7 +58,7 @@ def _ensure_registered() -> None:
 def get_protocol(
     protocol_id: str = "",
     *,
-    default_protocol: str = "xml",
+    default_protocol: str = "entml",
     custom_prompt_en: str = "",
     custom_prompt_zh: str = "",
     platform_id: str = "",

{echotools-1.0.36 → echotools-2.0.0}/src/echotools/protocol/base.py

@@ -18,12 +18,7 @@ __all__ = [
 logger = get_logger(__name__)
 
 VALID_PROTOCOL_IDS = (
-    "xml",
-    "antml",
-    "original",
-    "bracket",
-    "nous",
-    "dsml",
+    "entml",
     "custom",
 )
 

{echotools-1.0.36 → echotools-2.0.0}/src/echotools.egg-info/PKG-INFO

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

{echotools-1.0.36 → echotools-2.0.0}/src/echotools.egg-info/SOURCES.txt

@@ -44,13 +44,7 @@ src/echotools/fncall/prompt/history.py
 src/echotools/fncall/prompt/inject.py
 src/echotools/fncall/prompt/templates.py
 src/echotools/fncall/protocols/__init__.py
-src/echotools/fncall/protocols/antml.py
-src/echotools/fncall/protocols/bracket.py
-src/echotools/fncall/protocols/custom.py
-src/echotools/fncall/protocols/dsml.py
-src/echotools/fncall/protocols/nous.py
-src/echotools/fncall/protocols/original.py
-src/echotools/fncall/protocols/xml.py
+src/echotools/fncall/protocols/entml.py
 src/echotools/fncall/shared/__init__.py
 src/echotools/fncall/shared/coercion.py
 src/echotools/fncall/shared/loop_detect.py

echotools-1.0.36/src/echotools/fncall/protocols/__init__.py

@@ -1,30 +0,0 @@
-"""协议注册。
-
-导入时自动注册所有内置协议。
-"""
-
-from echotools.protocol.base import register_protocol
-
-
-def _register_all() -> None:
-    """注册所有内置协议。"""
-    from echotools.fncall.protocols.antml import AntmlProtocol
-    from echotools.fncall.protocols.bracket import BracketProtocol
-    from echotools.fncall.protocols.dsml import DsmlProtocol
-    from echotools.fncall.protocols.nous import NousProtocol
-    from echotools.fncall.protocols.original import OriginalProtocol
-    from echotools.fncall.protocols.xml import XmlProtocol
-
-    register_protocol(XmlProtocol())
-    register_protocol(AntmlProtocol())
-    register_protocol(OriginalProtocol())
-    register_protocol(BracketProtocol())
-    register_protocol(NousProtocol())
-    register_protocol(DsmlProtocol())
-    # custom 协议按需创建，不在此注册
-
-
-# 模块导入时自动注册
-_register_all()
-
-__all__ = ["_register_all"]

echotools-1.0.36/src/echotools/fncall/protocols/bracket.py

@@ -1,158 +0,0 @@
-import json
-import re
-from typing import List, Tuple
-
-from echotools.fncall.prompt.templates import (
-    _HISTORY_CLARIFY_EN,
-    _HISTORY_CLARIFY_ZH,
-)
-from echotools.fncall.shared.coercion import (
-    _build_param_schema_index,
-    _coerce_param_value,
-)
-from echotools.protocol.base import ToolProtocol
-
-
-class BracketProtocol(ToolProtocol):
-    @property
-    def id(self) -> str:
-        return "bracket"
-
-    _TRIGGER = "[function_calls]"
-    _END_TAG = "[/function_calls]"
-    _BLOCK_RE = re.compile(r"\[function_calls\]([\s\S]*?)\[/function_calls\]", re.DOTALL)
-    _CALL_RE = re.compile(r"\[call:([^\]]+)\]([\s\S]*?)\[/call\]", re.DOTALL)
-    # Fallback for incorrect [ToolName]{...}[/ToolName] format — only when body starts with {
-    _SIMPLE_CALL_RE = re.compile(r"\[([A-Za-z_][A-Za-z0-9_]*)\](\{[\s\S]*?)\[/\1\]", re.DOTALL)
-
-    def get_trigger_tags(self) -> List[str]:
-        return [self._TRIGGER]
-
-    def render_prompt(self, tool_descs, lang, user_system_prompt="", history_text="", loop_warning="", current_user_message=""):
-        instruction = f"""## Available Tools
-You can invoke the following developer tools. Tool names are case-sensitive.
-Use only the exact tool names listed below. Do not rename, camelCase, translate, shorten, or invent tool names.
-
-{tool_descs}
-
-## Tool Invocation Format
-
-When calling tools, you MUST respond with ONLY this exact bracket format:
-
-[function_calls]
-[call:exact_tool_name]{{"argument_name":"argument_value"}}[/call]
-[/function_calls]
-
-Rules:
-1. Always wrap tool calls in [function_calls]...[/function_calls]
-2. Use [call:tool_name]...[/call] for each invocation (note the colon before tool name)
-3. Arguments must be valid JSON inside the [call] tags
-4. Tool names are case-sensitive — use exact names from the list above
-5. Do NOT use [ToolName]{{...}}[/ToolName] format — that is incorrect
-6. Do NOT output plain text between [function_calls] tags
-
-Example correct invocation:
-[function_calls]
-[call:Bash]{{"command":"echo hello"}}[/call]
-[/function_calls]
-
-Tool results will be provided in a corresponding result block."""
-
-        sections = [instruction]
-        if user_system_prompt and user_system_prompt.strip():
-            sections.append(f"<user_system_prompt>\n{user_system_prompt.strip()}\n</user_system_prompt>")
-        if history_text:
-            clarify = _HISTORY_CLARIFY_ZH if lang == "zh" else _HISTORY_CLARIFY_EN
-            sections.append(f"<conversation_history>\n{clarify}\n\n{history_text}\n</conversation_history>")
-        if loop_warning:
-            sections.append(f"<loop_warning>\n{loop_warning}\n</loop_warning>")
-        if current_user_message:
-            sections.append(f"<current_user_message>\n{current_user_message}\n</current_user_message>")
-
-        return "\n\n".join(sections)
-
-    def detect_start(self, buffer: str) -> Tuple[bool, int]:
-        pos = buffer.find(self._TRIGGER)
-        return (pos >= 0, pos if pos >= 0 else -1)
-
-    def parse(self, text, tools=None):
-        tool_calls = []
-        schema_index = _build_param_schema_index(tools) if tools else None
-
-        for block_m in self._BLOCK_RE.finditer(text):
-            block_body = block_m.group(1)
-            block_had_correct_calls = False
-
-            # Try correct [call:name]{...}[/call] format first
-            for call_m in self._CALL_RE.finditer(block_body):
-                name = call_m.group(1).strip()
-                args_raw = call_m.group(2).strip()
-                args = self._parse_args(args_raw, name, schema_index)
-                tool_calls.append({
-                    "id": f"call_{len(tool_calls):04d}",
-                    "type": "function",
-                    "function": {"name": name, "arguments": args},
-                })
-                block_had_correct_calls = True
-
-            # Fallback: if no correct calls in this block, try simplified [ToolName]{...}[/ToolName]
-            if not block_had_correct_calls:
-                for simple_m in self._SIMPLE_CALL_RE.finditer(block_body):
-                    name = simple_m.group(1).strip()
-                    # Skip if it looks like a block tag
-                    if name.lower() in ('function_calls', 'call'):
-                        continue
-                    args_raw = simple_m.group(2).strip()
-                    # Only treat as fallback if body looks like JSON or plain text
-                    args = self._parse_args(args_raw, name, schema_index)
-                    tool_calls.append({
-                        "id": f"call_{len(tool_calls):04d}",
-                        "type": "function",
-                        "function": {"name": name, "arguments": args},
-                    })
-
-        clean = text
-        if tool_calls:
-            clean = self._BLOCK_RE.sub("", text).strip()
-
-        return (clean, tool_calls)
-
-    def _parse_args(self, args_raw, func_name, schema_index):
-        """Parse and optionally coerce arguments."""
-        try:
-            args = json.loads(args_raw)
-            if not isinstance(args, dict):
-                args = {"value": args_raw}
-        except json.JSONDecodeError:
-            args = {"value": args_raw}
-
-        # Apply schema coercion
-        if schema_index and func_name in schema_index:
-            coerced = {}
-            for k, v in args.items():
-                pschema = schema_index[func_name].get(k, {})
-                coerced[k] = _coerce_param_value(
-                    json.dumps(v) if not isinstance(v, str) else v,
-                    pschema,
-                )
-            args = coerced
-
-        return json.dumps(args, ensure_ascii=False)
-
-    def parse_fragment(self, fragment, tools=None):
-        _, tool_calls = self.parse(fragment, tools)
-        return tool_calls
-
-    def clean_tags(self, content):
-        return self._BLOCK_RE.sub("", content).strip()
-
-    def format_assistant_tool_calls(self, tool_calls):
-        calls = []
-        for tc in tool_calls:
-            fn = tc.get("function", {})
-            calls.append(f"[call:{fn.get('name', '')}]{fn.get('arguments', '{}')}[/call]")
-        joined = "\n".join(calls)
-        return f"[function_calls]\n{joined}\n[/function_calls]"
-
-    def supports_streaming(self):
-        return True

echotools-1.0.36/src/echotools/fncall/protocols/custom.py

@@ -1,51 +0,0 @@
-from typing import List, Tuple
-
-from echotools.protocol.base import ToolProtocol
-
-
-class CustomProtocol(ToolProtocol):
-    """用户自定义 prompt 协议。
-
-    不解析响应，依赖平台原生 tool_calls。
-    仅注入用户提供的 prompt 模板。
-    """
-
-    def __init__(self, prompt_en: str = "", prompt_zh: str = ""):
-        self._prompt_en = prompt_en
-        self._prompt_zh = prompt_zh
-
-    @property
-    def id(self) -> str:
-        return "custom"
-
-    def get_trigger_tags(self) -> List[str]:
-        return []
-
-    def render_prompt(self, tool_descs, lang, user_system_prompt="", history_text="", loop_warning="", current_user_message=""):
-        template = self._prompt_en if lang == "en" else self._prompt_zh
-        if not template:
-            return ""
-
-        # Simple template substitution
-        prompt = template
-        prompt = prompt.replace("{tool_descs}", tool_descs)
-        prompt = prompt.replace("{history_text}", history_text)
-        prompt = prompt.replace("{loop_warning}", loop_warning)
-        prompt = prompt.replace("{current_user_message}", current_user_message)
-        prompt = prompt.replace("{user_system_prompt}", user_system_prompt)
-        return prompt
-
-    def detect_start(self, buffer: str) -> Tuple[bool, int]:
-        return (False, -1)
-
-    def parse(self, text, tools=None):
-        return (text, [])
-
-    def parse_fragment(self, fragment, tools=None):
-        return []
-
-    def clean_tags(self, content):
-        return content.strip()
-
-    def supports_streaming(self):
-        return False