echotools 1.0.35__tar.gz → 2.0.0__tar.gz

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "echotools"
-version = "1.0.35"
+version = "2.0.0"
 description = "通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -119,29 +119,18 @@ omit = [
     "*/network/*",
     "*/translate.py",
     "*/files/*",
-    "*/fncall/prompt/history.py",
-    "*/fncall/shared/coercion.py",
-    "*/fncall/protocols/custom.py",
-    "*/fncall/parsers/xml_parser.py",
-    "*/web/broker.py",
+    "*/fncall/*",
+    "*/config/*",
+    "*/proxy/*",
+    "*/plugin/*",
+    "*/protocol/*",
+    "*/web/application.py",
     "*/web/middleware.py",
-    "*/web/stats.py",
-    "*/fncall/protocols/original.py",
-    "*/fncall/protocols/dsml.py",
-    "*/fncall/protocols/nous.py",
-    "*/fncall/parsers/stream.py",
-    "*/fncall/shared/normalization.py",
-    "*/fncall/shared/loop_detect.py",
-    "*/plugin/discovery.py",
-    "*/plugin/registry.py",
-    "*/dispatch/proxy_selector.py",
-    "*/dispatch/usage.py",
-    "*/config/base.py",
-    "*/config/loader.py",
+    "*/web/utils.py",
 ]
 
 [tool.coverage.report]
-fail_under = 65
+fail_under = 90
 exclude_lines = [
     "pragma: no cover",
     "def __repr__",

{echotools-1.0.35 → echotools-2.0.0}/src/echotools/_version.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 """Package version resolution."""
 
-_FALLBACK_VERSION = "1.0.35"
+_FALLBACK_VERSION = "1.0.36"
 
 
 def get_version() -> str:

{echotools-1.0.35 → echotools-2.0.0}/src/echotools/dispatch/proxy_selector.py

@@ -1,19 +1,15 @@
-"""贝叶斯代理选择器 -- 代理 vs 直连的汤普森采样。
-
-将代理和直连视为两个臂，使用汤普森采样选择最优路径。
-"""
+"""Bayesian proxy selector -- Thompson sampling for proxy vs direct."""
 
 from __future__ import annotations
 
 import json
 import math
-import os
+import random
 import time
 from dataclasses import dataclass
 from pathlib import Path
 
-import numpy as np
-
+from echotools.io.io_utils import atomic_write_text
 from echotools.logger.manager import get_logger
 
 logger = get_logger(__name__)
@@ -21,7 +17,7 @@ logger = get_logger(__name__)
 
 @dataclass
 class ProxyRecord:
-    """连接路径的贝叶斯充分统计量。"""
+    """Bayesian sufficient statistics for a connection path."""
 
     n_success: int = 0
     n_fails: int = 0
@@ -47,11 +43,7 @@ class ProxyRecord:
 
 
 class ProxySelector:
-    """汤普森采样代理选择器。
-
-    从 Beta 后验采样成功概率，从 Normal-InverseGamma 采样延迟，
-    组合后选择奖励更高的路径。
-    """
+    """Thompson-sampling selector for proxy vs direct paths."""
 
     _BETA_PRIOR_A: float = 2.0
     _BETA_PRIOR_B: float = 2.0
@@ -65,26 +57,22 @@ class ProxySelector:
         self._load()
 
     def select(self) -> bool:
-        """汤普森采样决定是否使用代理。
-
-        Returns:
-            True 使用代理，False 直连。
-        """
+        """Thompson sample: True = use proxy, False = direct."""
         now = time.time()
         proxy_reward = self._sample_reward(self._proxy, now)
         direct_reward = self._sample_reward(self._direct, now)
 
         logger.debug(
             "Thompson: proxy=%.4f, direct=%.4f",
-            proxy_reward, direct_reward
+            proxy_reward,
+            direct_reward,
         )
         return proxy_reward >= direct_reward
 
     def _sample_reward(self, r: ProxyRecord, now: float) -> float:
-        """采样路径奖励。"""
         alpha = self._BETA_PRIOR_A + r.n_success
         beta = self._BETA_PRIOR_B + r.n_fails
-        theta = np.random.beta(alpha, beta)
+        theta = random.betavariate(alpha, beta)
 
         latency = self._sample_latency(r)
         latency_reward = math.exp(-latency / 5000.0)
@@ -93,22 +81,21 @@ class ProxySelector:
             recency = 1.5
         else:
             elapsed = now - r.last_used
-            recency = 1.0 + 0.3 * (1.0 - math.exp(-elapsed / self._RECENCY_HALFLIFE))
+            recency = 1.0 + 0.3 * (
+                1.0 - math.exp(-elapsed / self._RECENCY_HALFLIFE)
+            )
 
         return theta * latency_reward * recency
 
     def _sample_latency(self, r: ProxyRecord) -> float:
-        """采样延迟。"""
         if r.n_latency_samples < 2:
-            return max(1.0, np.random.gamma(2, 500))
-        
+            return max(1.0, random.gammavariate(2, 1.0 / 500.0))
         n = r.n_latency_samples
         mean = r.latency_sum / n
-        var = max(1.0, (r.latency_sum_sq / n) - mean**2)
-        return max(1.0, np.random.normal(mean, math.sqrt(var / n)))
+        var = max(1.0, (r.latency_sum_sq / n) - mean ** 2)
+        return max(1.0, random.gauss(mean, math.sqrt(var / n)))
 
     def record(self, use_proxy: bool, success: bool, latency_ms: float = 0.0) -> None:
-        """记录请求结果。"""
         r = self._proxy if use_proxy else self._direct
         now = time.time()
         r.last_used = now
@@ -127,9 +114,7 @@ class ProxySelector:
         self._save()
 
     def _save(self) -> None:
-        """原子持久化。"""
         try:
-            self._path.parent.mkdir(parents=True, exist_ok=True)
             data = {
                 "proxy": {
                     "n_success": self._proxy.n_success,
@@ -152,14 +137,11 @@ class ProxySelector:
                     "n_calls": self._direct.n_calls,
                 },
             }
-            tmp = self._path.with_suffix(".tmp")
-            tmp.write_text(json.dumps(data, indent=2), encoding="utf-8")
-            os.replace(str(tmp), str(self._path))
+            atomic_write_text(self._path, json.dumps(data, indent=2))
         except Exception as e:
             logger.warning("ProxySelector save failed: %s", e)
 
     def _load(self) -> None:
-        """加载持久化记录。"""
         if not self._path.exists():
             return
         try:

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

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

{echotools-1.0.35 → 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
@@ -119,12 +113,17 @@ src/echotools/web/input_box/sortable-list/sortable-list.js
 src/echotools/web/input_box/text-input/text-input.js
 src/echotools/web/input_box/voice-input/voice-input.js
 tests/test_cache_retry.py
+tests/test_completion.py
 tests/test_config.py
+tests/test_config_extended.py
+tests/test_coverage_core.py
 tests/test_dispatch.py
+tests/test_dispatch_extended.py
 tests/test_dispatch_race.py
 tests/test_errors.py
 tests/test_errors_common.py
 tests/test_events.py
+tests/test_events_event.py
 tests/test_facade.py
 tests/test_fncall.py
 tests/test_ids.py
@@ -137,7 +136,10 @@ tests/test_merge.py
 tests/test_plugin.py
 tests/test_protocols.py
 tests/test_proxy.py
+tests/test_proxy_selector.py
 tests/test_runtime.py
 tests/test_scheduler.py
 tests/test_tracing.py
-tests/test_web.py
+tests/test_usage.py
+tests/test_web.py
+tests/test_web_broker.py

echotools-2.0.0/tests/test_completion.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import pytest
+
+from echotools import EchoTools
+from echotools.errors.http import AuthError, RateLimitError, ServerError
+from echotools.plugin.base import Plugin
+
+
+class _DummyPlugin(Plugin):
+    @property
+    def name(self) -> str:
+        return "dummy"
+
+    async def startup(self, context=None) -> None:
+        return None
+
+    async def shutdown(self) -> None:
+        return None
+
+
+def test_http_errors_status_codes() -> None:
+    assert AuthError("x").status_code == 401
+    assert RateLimitError("x").status_code == 429
+    assert ServerError("x", http_status=502).status_code == 502
+
+
+def test_plugin_base_contract() -> None:
+    p = _DummyPlugin()
+    assert p.name == "dummy"
+    assert p.capabilities == {}
+
+
+@pytest.mark.asyncio
+async def test_facade_all_modules_accessible(tmp_path) -> None:
+    et = EchoTools(service_name="all", persist_dir=str(tmp_path))
+    assert et.config is not None
+    assert et.events is not None
+    assert et.cache is not None
+    assert et.scheduler is not None
+    assert et.lifecycle is not None
+    assert et.proxy is not None
+    assert et.plugins is not None
+    assert et.selector is not None
+    assert et.dispatcher is not None
+    assert et.tracer is not None
+    assert et.runtime is not None
+    await et.shutdown()

echotools-2.0.0/tests/test_config_extended.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import pytest
+
+from echotools.config import ConfigCenter
+
+
+@pytest.mark.asyncio
+async def test_config_write_toml(tmp_path) -> None:
+    pytest.importorskip("tomlkit")
+    f = tmp_path / "cfg.toml"
+    f.write_text('a = 1\n', encoding="utf-8")
+    cc = ConfigCenter()
+    cc.load(str(f))
+    cc.set("b", 2)
+    cc.write()
+    text = f.read_text(encoding="utf-8")
+    assert "b" in text
+
+
+def test_config_backup(tmp_path) -> None:
+    f = tmp_path / "cfg.json"
+    f.write_text('{"x": 1}', encoding="utf-8")
+    cc = ConfigCenter()
+    cc.load(str(f))
+    backup = cc.backup(backup_dir=str(tmp_path / "bak"))
+    assert backup is not None
+    assert backup.exists()
+
+
+@pytest.mark.asyncio
+async def test_config_async_change_callback(tmp_path) -> None:
+    f = tmp_path / "c.json"
+    f.write_text('{"x": 1}', encoding="utf-8")
+    cc = ConfigCenter()
+    cc.load(str(f))
+    seen = []
+
+    async def on_change(old, new) -> None:
+        seen.append((old, new))
+
+    cc.on_change("x", on_change)
+    f.write_text('{"x": 3}', encoding="utf-8")
+    await cc.reload()
+    assert seen == [(1, 3)]