echotools 2.3.45__tar.gz → 2.3.47__tar.gz

{echotools-2.3.45 → echotools-2.3.47}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.3.45
+Version: 2.3.47
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
+Home-page: https://github.com/nichengfuben/echotools
 Author: nichengfuben
 License: MIT
 Project-URL: Homepage, https://github.com/nichengfuben/echotools

{echotools-2.3.45 → echotools-2.3.47}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "echotools"
-version = "2.3.45"
+version = "2.3.47"
 description = "通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链"
 readme = "docs/README.md"
 requires-python = ">=3.8"
@@ -98,7 +98,7 @@ module = "echotools.exec.terminal.*"
 ignore_errors = true
 
 [[tool.mypy.overrides]]
-module = "echotools.media.console.ui"
+module = "echotools.media.console.*"
 ignore_errors = true
 
 [tool.pytest.ini_options]

echotools-2.3.47/setup.cfg

@@ -0,0 +1,8 @@
+[metadata]
+url = https://github.com/nichengfuben/echotools
+home_page = https://github.com/nichengfuben/echotools
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

{echotools-2.3.45 → echotools-2.3.47}/src/echotools/exec/fncall/parsers/stream.py

@@ -52,6 +52,8 @@ class FncallStreamParser:
         self._thinking_parts: List[str] = []
         self._thinking_filter = _make_thinking_filter(protocol)
         self._emitted_invoke_count: int = 0
+        self._json_stream_encoder = None
+        self._pending_stream_delta: Optional[Tuple[str, str]] = None
 
         # 三种情况：
         #   1. 协议实现了 get_stream_end_tags() 且返回非空列表  → 用声明的结束标记
@@ -140,13 +142,28 @@ class FncallStreamParser:
         if text:
             self._text_parts.append(text)
 
+    def _normalize_stream_chunk(self, text: str) -> str:
+        fn = getattr(self._protocol, "normalize_stream_buffer", None)
+        if callable(fn):
+            return fn(text)
+        return text
+
     def _feed_content_waiting(self, text: str) -> None:
         """thinking 已闭合后，对可见正文做 invoke 检测（不再经过 thinking 过滤器）。"""
         if not text:
             return
+        text = self._normalize_stream_chunk(text)
         trigger_tags = self._protocol.get_trigger_tags()
         found, pos = self._protocol.detect_start(text)
         if not found:
+            hold_from_fn = getattr(self._protocol, "find_fncall_hold_from", None)
+            if hold_from_fn is not None:
+                hold_from = hold_from_fn(text)
+                if hold_from is not None:
+                    if hold_from > 0:
+                        self._append_content_text(text[:hold_from])
+                    self._waiting_tail = text[hold_from:]
+                    return
             safe, remain = self._split_safe_text(text, trigger_tags)
             if safe:
                 self._append_content_text(safe)
@@ -173,7 +190,7 @@ class FncallStreamParser:
 
     def _feed_waiting(self, chunk: str) -> None:
         """在 WAITING_FOR_TAG 状态下处理新块。"""
-        combined = self._waiting_tail + chunk
+        combined = self._normalize_stream_chunk(self._waiting_tail + chunk)
         self._waiting_tail = ""
 
         # 已进入 thinking 块时，块内不做 invoke 检测。
@@ -196,8 +213,8 @@ class FncallStreamParser:
             return
 
         # 无完整工具开标签时，再处理未闭合 thinking / 思考开标签 holdback。
-        # 必须放在 detect_start 之后：否则 `<entml:function_calls>\n<en` 会被
-        # 尾部 `<en` 误判为 thinking 前缀，导致 invoke 内容被截断。
+        # 必须放在 detect_start 之后：否则 legacy 外壳后的 `<en` 会被
+        # 尾部误判为 thinking 前缀，导致 invoke 内容被截断。
         if self._thinking_filter is not None:
             from echotools.exec.fncall.protocols.entml_think.parse import (
                 has_unclosed_entml_thinking,
@@ -206,6 +223,15 @@ class FncallStreamParser:
                 self._feed_waiting_thinking_plain(combined)
                 return
 
+        hold_from_fn = getattr(self._protocol, "find_fncall_hold_from", None)
+        if hold_from_fn is not None:
+            hold_from = hold_from_fn(combined)
+            if hold_from is not None:
+                if hold_from > 0:
+                    self._emit_text(combined[:hold_from])
+                self._waiting_tail = combined[hold_from:]
+                return
+
         safe, remain = self._split_safe_text(combined, trigger_tags)
         if safe:
             self._emit_text(safe)
@@ -222,9 +248,11 @@ class FncallStreamParser:
         return False
 
     def feed(self, chunk: str) -> List[Dict[str, Any]]:
-        """喂入新的流式文本块，返回本轮新完成的 tool_calls（可空列表）。
+        """喂入新的流式文本块。
 
-        DONE 或 finalize 后调用静默忽略并返回 ``[]``。
+        返回本轮新完成的 tool_calls（与 ``get_ready_tool_calls()`` 相同语义：
+        调用后计数前进，勿再对本轮结果重复调用 ``get_ready_tool_calls``）。
+        DONE 或 finalize 后调用返回 ``[]``。
         """
         if not chunk or self._state == self.DONE:
             return []
@@ -236,11 +264,45 @@ class FncallStreamParser:
         if self._state == self.WAITING_FOR_TAG:
             self._feed_waiting(chunk)
         else:
-            self._fncall_buf += chunk
+            self._fncall_buf += self._normalize_stream_chunk(chunk)
             if self._is_call_closed():
                 self._state = self.DONE
 
-        return self.get_ready_tool_calls()
+        self._pending_stream_delta = self._poll_streaming_tool_input_delta()
+        ready = self.get_ready_tool_calls()
+        if ready:
+            if self._json_stream_encoder is not None:
+                self._json_stream_encoder.reset()
+        return ready
+
+    def _poll_streaming_tool_input_delta(self) -> Optional[Tuple[str, str]]:
+        """invoke 开标签完整匹配后，返回 (tool_name, partial_json_delta)。"""
+        if not self._detected or getattr(self._protocol, "id", None) != "entml":
+            return None
+        if self._state not in (self.IN_FUNCTION_CALLS, self.DONE):
+            return None
+        from echotools.exec.fncall.protocols.entml_stream_json import (
+            EntmlInvokeJsonStreamEncoder,
+            split_invoke_open,
+        )
+
+        parsed = split_invoke_open(self._fncall_buf)
+        if not parsed:
+            return None
+        name, body_start = parsed
+        body = self._fncall_buf[body_start:]
+        if self._json_stream_encoder is None:
+            self._json_stream_encoder = EntmlInvokeJsonStreamEncoder()
+        delta = self._json_stream_encoder.poll(body)
+        if not delta:
+            return None
+        return (name, delta)
+
+    def consume_stream_delta(self) -> Optional[Tuple[str, str]]:
+        """取出本轮 ``feed`` 产生的 streaming partial_json 增量。"""
+        delta = self._pending_stream_delta
+        self._pending_stream_delta = None
+        return delta
 
     def _assembly_for_tool_parse(self) -> str:
         """可供工具解析的已缓冲文本（不含 thinking 过滤器内部 pending）。"""

{echotools-2.3.45 → echotools-2.3.47}/src/echotools/exec/fncall/prompt/inject.py

@@ -147,11 +147,17 @@ def inject_fncall(
     if not tools:
         if protocol.id == "entml":
             sections: List[str] = []
+            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.strip():
                 sections.append(format_entml_conversation_history(history_text))
             sections.append(format_entml_current_user_message(current_user_message))
             # thinking 放在最后，超限截断时优先保留在 send_text 尾部
-            thinking_section = build_entml_thinking_section(protocol_options)
+            thinking_section = build_entml_thinking_section(
+                protocol_options, has_tools=False
+            )
             if thinking_section:
                 sections.append(thinking_section)
             prompt = "\n\n".join(sections)

{echotools-2.3.45 → echotools-2.3.47}/src/echotools/exec/fncall/protocols/entml.py

@@ -1,6 +1,6 @@
 """Entropy ML (entml) 协议实现。
 
-- 工具调用：<entml:function_calls> / <entml:invoke> / <entml:parameter>
+- 工具调用：<entml:invoke> / <entml:parameter>（legacy ``function_calls`` 外壳仅解析兼容）
 - 对话历史：<entml:conversation_history>
 - 当前用户消息：<current_user_message>
 """
@@ -20,6 +20,9 @@ from echotools.exec.fncall.protocols.entml_invoke import (
 )
 from echotools.exec.fncall.protocols.entml_patterns import (
     BLOCK_RE,
+    extract_attr_value,
+    normalize_entml_name,
+    strip_legacy_function_calls_wrapper,
     strip_tool_entml_residue,
 )
 from echotools.exec.fncall.protocols.entml_think.core import (
@@ -136,20 +139,22 @@ class EntmlProtocol(ToolProtocol):
 
     _TRIGGER = "<entml:invoke>"
     _TRIGGER_PREFIX = "<entml:invoke"
-    _WRAPPER_PREFIX = "<entml:function_calls"
+    _LEGACY_WRAPPER_PREFIX = "<entml:function_calls"
     _THINKING_PREFIX = "<entml:thinking"
 
     def get_trigger_tags(self) -> List[str]:
-        # invoke / function_calls / thinking 前缀一并 holdback，避免 `<e` 歧义被提前吐出
+        # invoke / thinking 前缀 holdback，避免 `<e` 歧义被提前吐出
         return [
             self._TRIGGER,
             self._TRIGGER_PREFIX,
-            self._WRAPPER_PREFIX,
-            f"{self._WRAPPER_PREFIX}>",
             self._THINKING_PREFIX,
             f"{self._THINKING_PREFIX}>",
         ]
 
+    def normalize_stream_buffer(self, buffer: str) -> str:
+        """流式处理前剥离 legacy function_calls 外壳（提示词已不再要求）。"""
+        return strip_legacy_function_calls_wrapper(buffer)
+
     def get_stream_end_tags(self) -> List[str]:
         """新格式无外层 wrapper，不自动关闭流，由 finalize() 统一解析。"""
         return []
@@ -194,25 +199,52 @@ class EntmlProtocol(ToolProtocol):
         sections.append(format_entml_current_user_message(current_user_message))
 
         # thinking 放在最后，超限截断时优先保留在 send_text 尾部
-        thinking_section = build_entml_thinking_section(protocol_options)
+        thinking_section = build_entml_thinking_section(
+            protocol_options, has_tools=bool(tool_descs)
+        )
         if thinking_section:
             sections.append(thinking_section)
 
         return "\n\n".join(sections)
 
     def detect_start(self, buffer: str) -> Tuple[bool, int]:
-        candidates: List[int] = []
-        for prefix in (self._WRAPPER_PREFIX, self._TRIGGER_PREFIX):
-            pos = buffer.find(prefix)
+        """invoke 开标签（含 name 且闭合 ``>``）稳定后才视为工具流开始。"""
+        invoke_pos = self._find_complete_invoke_open(buffer)
+        if invoke_pos < 0:
+            return (False, -1)
+        return (True, invoke_pos)
+
+    def find_fncall_hold_from(self, buffer: str) -> Optional[int]:
+        """invoke 未稳定前 hold 前缀；legacy 外壳开标签未闭合时同样 hold。"""
+        if self._find_complete_invoke_open(buffer) >= 0:
+            return None
+        hold: Optional[int] = None
+        legacy_pos = buffer.find(self._LEGACY_WRAPPER_PREFIX)
+        if legacy_pos >= 0:
+            close = buffer.find(">", legacy_pos)
+            if close < 0 and (hold is None or legacy_pos < hold):
+                hold = legacy_pos
+        invoke_pos = buffer.find(self._TRIGGER_PREFIX)
+        if invoke_pos >= 0 and (hold is None or invoke_pos < hold):
+            hold = invoke_pos
+        return hold
+
+    def _find_complete_invoke_open(self, buffer: str) -> int:
+        """返回首个含 name 且已闭合 ``>`` 的 ``<entml:invoke`` 起始下标；否则 -1。"""
+        search_from = 0
+        prefix_len = len(self._TRIGGER_PREFIX)
+        while True:
+            pos = buffer.find(self._TRIGGER_PREFIX, search_from)
             if pos < 0:
-                continue
-            close = buffer.find(">", pos + len(prefix))
+                return -1
+            close = buffer.find(">", pos + prefix_len)
             if close < 0:
-                continue
-            candidates.append(pos)
-        if not candidates:
-            return (False, -1)
-        return (True, min(candidates))
+                return -1
+            attrs = buffer[pos + prefix_len : close]
+            name = extract_attr_value(attrs, "name")
+            if name and normalize_entml_name(name):
+                return pos
+            search_from = close + 1
 
     def parse(
         self,

{echotools-2.3.45 → echotools-2.3.47}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -93,7 +93,7 @@ def format_entml_parameter_value(value: Any) -> str:
 
 
 def format_entml_tool_calls(tool_calls: List[Dict[str, Any]]) -> str:
-    """将 tool_call 列表渲染为 entml function_calls 块。"""
+    """将 tool_call 列表渲染为裸 ``<entml:invoke>`` 块（无 function_calls 外壳）。"""
     if not tool_calls:
         return ""
 

{echotools-2.3.45 → echotools-2.3.47}/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -39,6 +39,15 @@ _TOOL_WRAPPER_PAIR_RE = re.compile(
     r"<entml:function_calls\b[^>]*>[\s\S]*?</entml:function_calls>",
     re.DOTALL,
 )
+# 旧版 function_calls 外壳（提示词已不再要求；流式/解析前静默剥离完整开闭标签）。
+_LEGACY_WRAPPER_OPEN_RE = re.compile(
+    r"<entml:function_calls\b[^>]*>\s*",
+    re.IGNORECASE,
+)
+_LEGACY_WRAPPER_CLOSE_RE = re.compile(
+    r"\s*</entml:function_calls\s*>",
+    re.IGNORECASE,
+)
 _TOOL_ORPHAN_TAG_RE = re.compile(
     r"</?entml:(?:function_calls|invoke|parameter|parameters)\b[^>]*/?>",
     re.DOTALL,
@@ -98,6 +107,15 @@ def parse_sub_tags(
     return args
 
 
+def strip_legacy_function_calls_wrapper(text: str) -> str:
+    """移除完整 legacy ``<entml:function_calls>`` 开/闭标签（裸 invoke 为一等格式）。"""
+    if not text:
+        return text
+    out = _LEGACY_WRAPPER_OPEN_RE.sub("", text)
+    out = _LEGACY_WRAPPER_CLOSE_RE.sub("", out)
+    return out
+
+
 def strip_tool_entml_residue(content: str) -> str:
     """剥离工具相关 entml 标签残留，保留 thinking 等非工具标签。"""
     if not content:

echotools-2.3.47/src/echotools/exec/fncall/protocols/entml_stream_json.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+from .entml_patterns import extract_attr_value, normalize_entml_name
+
+_PARAM_OPEN_RE = re.compile(r"<entml:parameter\b([^>]*)>", re.IGNORECASE)
+_PARAM_CLOSE = "</entml:parameter>"
+_INVOKE_CLOSE = "</entml:invoke>"
+_INVOKE_OPEN_PREFIX = "<entml:invoke"
+
+
+def _strip_incomplete_markup_suffix(value: str) -> str:
+    lt = value.rfind("<")
+    if lt < 0:
+        return value
+    tail = value[lt:]
+    for tag in (_PARAM_CLOSE, _INVOKE_CLOSE):
+        if tag.startswith(tail) and tail != tag:
+            return value[:lt]
+    return value
+
+
+def split_invoke_open(buffer: str) -> Optional[Tuple[str, int]]:
+    search_from = 0
+    prefix_len = len(_INVOKE_OPEN_PREFIX)
+    while True:
+        pos = buffer.find(_INVOKE_OPEN_PREFIX, search_from)
+        if pos < 0:
+            return None
+        gt = buffer.find(">", pos + prefix_len)
+        if gt < 0:
+            return None
+        attrs = buffer[pos + prefix_len : gt]
+        name = extract_attr_value(attrs, "name")
+        if name and normalize_entml_name(name):
+            return normalize_entml_name(name), gt + 1
+        search_from = gt + 1
+
+
+def _json_string_body(value: str) -> str:
+    """JSON 字符串内部片段（不含外围引号）。"""
+    return json.dumps(value, ensure_ascii=False)[1:-1]
+
+
+def _parse_parameter_entries(body: str) -> List[Tuple[str, str, bool]]:
+    """返回 [(key, value, is_complete), ...]。"""
+    if not body:
+        return []
+    entries: List[Tuple[str, str, bool]] = []
+    i = 0
+    while i < len(body):
+        match = _PARAM_OPEN_RE.search(body, i)
+        if not match:
+            break
+        attrs = match.group(1) or ""
+        pname = extract_attr_value(attrs, "name")
+        if not pname:
+            i = match.end()
+            continue
+        key = normalize_entml_name(pname)
+        val_start = match.end()
+        close = body.find(_PARAM_CLOSE, val_start)
+        if close < 0:
+            entries.append((key, _strip_incomplete_markup_suffix(body[val_start:]), False))
+            break
+        entries.append((key, body[val_start:close], True))
+        i = close + len(_PARAM_CLOSE)
+    return entries
+
+
+def build_streaming_json_snapshot(body: str) -> str:
+    """构造当前应已发出的 partial_json 累积串（可未完成）。"""
+    invoke_closed = _INVOKE_CLOSE in body
+    inner = body[: body.index(_INVOKE_CLOSE)] if invoke_closed else body
+    entries = _parse_parameter_entries(inner)
+    if not entries:
+        return ""
+
+    parts: List[str] = ["{"]
+    for idx, (key, value, is_complete) in enumerate(entries):
+        if idx > 0:
+            parts.append(", ")
+        parts.append(json.dumps(key, ensure_ascii=False))
+        parts.append(": ")
+        parts.append('"')
+        parts.append(_json_string_body(value))
+        if is_complete:
+            parts.append('"')
+        else:
+            return "".join(parts)
+
+    if entries and all(entry[2] for entry in entries):
+        parts.append("}")
+    elif invoke_closed:
+        parts.append("}")
+    return "".join(parts)
+
+
+def _parse_partial_parameter_body(body: str) -> Dict[str, Any]:
+    obj: Dict[str, Any] = {}
+    for key, value, is_complete in _parse_parameter_entries(
+        body[: body.index(_INVOKE_CLOSE)] if _INVOKE_CLOSE in body else body
+    ):
+        if is_complete or value:
+            obj[key] = value
+    return obj
+
+
+def encode_streaming_invoke_json(body: str) -> str:
+    obj = _parse_partial_parameter_body(body)
+    if not obj:
+        return ""
+    return json.dumps(obj, ensure_ascii=False)
+
+
+class EntmlInvokeJsonStreamEncoder:
+    """invoke 开标签之后，将 growing body 编码为可拼接的 partial_json 增量。"""
+
+    def __init__(self) -> None:
+        self._emitted = ""
+
+    def poll(self, body: str) -> str:
+        snapshot = build_streaming_json_snapshot(body)
+        if not snapshot.startswith(self._emitted):
+            common = 0
+            for a, b in zip(self._emitted, snapshot):
+                if a != b:
+                    break
+                common += 1
+            delta = snapshot[common:]
+            self._emitted = snapshot
+            return delta
+        delta = snapshot[len(self._emitted) :]
+        self._emitted = snapshot
+        return delta
+
+    def reset(self) -> None:
+        self._emitted = ""

{echotools-2.3.45 → echotools-2.3.47}/src/echotools/exec/fncall/protocols/entml_think/core.py

@@ -62,16 +62,24 @@ _DEFAULT_MAX_BY_LEVEL: Dict[str, int] = {
 
 _LEGACY_ON_DEFAULT_MAX = _DEFAULT_MAX_BY_LEVEL["medium"]
 
-_THINKING_BEHAVIOR_ON = """\
+_THINKING_BEHAVIOR_ON_WITH_TOOLS = """\
 Your default is to think before it answers to give the person the best possible answer. Even for questions that might seem obvious, if there are any signs of lurking complexity, You takes the time to open up an extended thinking block and dig in to make sure it's got the details figured out and isn't just pattern-matching to the familiar. At the end of its thinking, You restates which language it should respond in.
 
 You MUST output a <entml:thinking> block before any other content in every reply. Only after that block, output your visible reply and/or <entml:invoke> tool call(s). Never skip the thinking block."""
 
-_THINKING_BEHAVIOR_AUTO = """\
+_THINKING_BEHAVIOR_ON_NO_TOOLS = """\
+Your default is to think before it answers to give the person the best possible answer. Even for questions that might seem obvious, if there are any signs of lurking complexity, You takes the time to open up an extended thinking block and dig in to make sure it's got the details figured out and isn't just pattern-matching to the familiar. At the end of its thinking, You restates which language it should respond in.
+
+You MUST output a <entml:thinking> block before any other content in every reply. Only after that block, output your visible reply. Never skip the thinking block."""
+
+_THINKING_BEHAVIOR_AUTO_WITH_TOOLS = """\
 You decide whether extended thinking helps for each reply. When the question has hidden complexity, when tool results need interpretation, or when you are uncertain, open a <entml:thinking> block before continuing and strongly prefer to do so rather than guessing.
 
 After completed tool turns appear in conversation history inside <tool> blocks (for example a line like [tool_name: value] followed by its result), strongly consider outputting a <entml:thinking> block before your next visible reply or tool call."""
 
+_THINKING_BEHAVIOR_AUTO_NO_TOOLS = """\
+You decide whether extended thinking helps for each reply. When the question has hidden complexity or when you are uncertain, open a <entml:thinking> block before continuing and strongly prefer to do so rather than guessing."""
+
 
 def normalize_thinking_level(level: Any) -> Optional[str]:
     """将 echotools 思考挡位归一化为 none | low | medium | high | xhigh | max | auto。"""
@@ -155,13 +163,18 @@ def _uses_forced_thinking_behavior(injection_mode: str) -> bool:
     return injection_mode != "auto"
 
 
-def _format_thinking_behavior(injection_mode: str) -> str:
-    body = _THINKING_BEHAVIOR_ON if _uses_forced_thinking_behavior(injection_mode) else _THINKING_BEHAVIOR_AUTO
+def _format_thinking_behavior(injection_mode: str, *, has_tools: bool) -> str:
+    if _uses_forced_thinking_behavior(injection_mode):
+        body = _THINKING_BEHAVIOR_ON_WITH_TOOLS if has_tools else _THINKING_BEHAVIOR_ON_NO_TOOLS
+    else:
+        body = _THINKING_BEHAVIOR_AUTO_WITH_TOOLS if has_tools else _THINKING_BEHAVIOR_AUTO_NO_TOOLS
     return f"<thinking_behavior>\n{body}\n</thinking_behavior>"
 
 
 def build_entml_thinking_section(
     protocol_options: Optional[Dict[str, Any]] = None,
+    *,
+    has_tools: bool = True,
 ) -> str:
     """按思考挡位构建注入块：thinking_mode + max_thinking_length + thinking_behavior。"""
     resolved = resolve_thinking_injection(protocol_options)
@@ -173,5 +186,5 @@ def build_entml_thinking_section(
     if max_length is not None:
         lines.append(f"<entml:max_thinking_length>{max_length}</entml:max_thinking_length>")
     lines.append("")
-    lines.append(_format_thinking_behavior(injection_mode))
+    lines.append(_format_thinking_behavior(injection_mode, has_tools=has_tools))
     return "\n".join(lines)