echotools 2.3.99__tar.gz → 2.3.100__tar.gz

{echotools-2.3.99 → echotools-2.3.100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echotools
-Version: 2.3.99
+Version: 2.3.100
 Summary: 通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链
 Home-page: https://github.com/nichengfuben/echotools
 Author: nichengfuben

{echotools-2.3.99 → echotools-2.3.100}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "echotools"
-version = "2.3.99"
+version = "2.3.100"
 description = "通用基础设施 SDK：配置、日志、事件、调度、插件、协议、调用链"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -76,7 +76,7 @@ ignore = ["E501", "E402"]
 known-first-party = ["echotools"]
 
 [tool.mypy]
-python_version = "3.8"
+python_version = "3.10"
 warn_return_any = true
 warn_unused_ignores = true
 disallow_untyped_defs = false
@@ -91,6 +91,8 @@ disable_error_code = [
     "arg-type",
     "attr-defined",
     "var-annotated",
+    "has-type",
+    "misc",
 ]
 
 [[tool.mypy.overrides]]
@@ -101,6 +103,10 @@ ignore_errors = true
 module = "echotools.media.console.*"
 ignore_errors = true
 
+[[tool.mypy.overrides]]
+module = "echotools.exec.fncall.parsers.*"
+disable_error_code = ["has-type", "misc", "return-value"]
+
 [tool.pytest.ini_options]
 testpaths = ["src/tests"]
 pythonpath = ["src", "src/tests"]

{echotools-2.3.99 → echotools-2.3.100}/src/echotools/exec/fncall/parsers/stream.py

@@ -23,8 +23,8 @@ def _make_thinking_filter(protocol: ToolProtocol, *, thinking_enabled: bool = Tr
     return None
 
 
-from echotools.exec.fncall.parsers.stream_feed import StreamFeedMixin
 from echotools.exec.fncall.parsers.stream_delta import StreamDeltaMixin
+from echotools.exec.fncall.parsers.stream_feed import StreamFeedMixin
 from echotools.exec.fncall.parsers.stream_final import StreamFinalMixin
 
 
@@ -101,7 +101,9 @@ class FncallStreamParser(StreamFeedMixin, StreamDeltaMixin, StreamFinalMixin):
         return self._schema_index
 
     def _get_known_tool_names(self):
-        from echotools.exec.fncall.protocols.entml_patterns import resolve_known_tool_names
+        from echotools.exec.fncall.protocols.entml_patterns import (
+            resolve_known_tool_names,
+        )
 
         return resolve_known_tool_names(self._tools, self._get_schema_index())
 

{echotools-2.3.99 → echotools-2.3.100}/src/echotools/exec/fncall/parsers/stream_feed.py

@@ -1,8 +1,6 @@
 """FncallStreamParser waiting/feed helpers."""
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Tuple
-
 
 class StreamFeedMixin:
     def _normalize_stream_chunk(self, text: str) -> str:

{echotools-2.3.99 → echotools-2.3.100}/src/echotools/exec/fncall/parsers/stream_final.py

@@ -1,7 +1,7 @@
 """FncallStreamParser finalize / partial display helpers."""
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Tuple
 
 
 class StreamFinalMixin:
@@ -13,11 +13,8 @@ class StreamFinalMixin:
         """与 batch ``parse`` 一致：未闭合 thinking 之后的正文不参与可见/剥离。"""
         from echotools.exec.fncall.protocols.entml_think.parse import (
             clean_stream_partial_visible,
-            stream_safe_visible_prefix,
-        )
-
-        from echotools.exec.fncall.protocols.entml_think.parse import (
             split_entml_thinking,
+            stream_safe_visible_prefix,
         )
 
         buf = stream_safe_visible_prefix(
@@ -34,12 +31,12 @@ class StreamFinalMixin:
 
     def _stream_display_text(self) -> str:
         """流式可见正文：在完整 raw 缓冲上剥离伪 history（保留 thinking 保护区）。"""
-        from echotools.exec.fncall.shared.history_markup import (
-            strip_fake_history_markup_for_display,
-        )
         from echotools.exec.fncall.protocols.entml_think.parse import (
             split_entml_thinking,
         )
+        from echotools.exec.fncall.shared.history_markup import (
+            strip_fake_history_markup_for_display,
+        )
 
         buf = self._stream_visible_buffer()
         if not buf:
@@ -52,14 +49,14 @@ class StreamFinalMixin:
 
     def _stream_partial_display_text(self) -> str:
         """流式 ``partial_text``：在 invoke 起点前截断 raw，保留尾部 holdback 空白。"""
-        from echotools.exec.fncall.shared.history_markup import (
-            strip_fake_history_markup_for_display,
-        )
         from echotools.exec.fncall.protocols.entml_think.parse import (
             clean_stream_partial_visible,
             split_entml_thinking,
             stream_safe_visible_prefix,
         )
+        from echotools.exec.fncall.shared.history_markup import (
+            strip_fake_history_markup_for_display,
+        )
 
         raw = self._raw_buf
         if not raw:

{echotools-2.3.99 → echotools-2.3.100}/src/echotools/exec/fncall/protocols/entml.py

@@ -14,7 +14,6 @@ from typing import Any, Dict, List, Optional, Tuple
 from echotools.exec.fncall.prompt.behavior_blocks import (
     format_function_calling_behavior,
     format_hard_constraint_restatement,
-    format_thinking_behavior,
 )
 from echotools.exec.fncall.prompt.templates import (
     _HISTORY_CLARIFY_EN,
@@ -25,23 +24,20 @@ from echotools.exec.fncall.protocols.entml_invoke import (
 )
 from echotools.exec.fncall.protocols.entml_patterns import (
     entml_invoke_open_may_be_streaming,
-    extract_attr_value,
     find_actionable_entml_invoke_open,
-    normalize_entml_name,
     resolve_known_tool_names,
     strip_actionable_entml_invoke_blocks,
     strip_legacy_function_calls_wrapper,
     strip_tool_entml_residue,
 )
+from echotools.exec.fncall.protocols.entml_schema import format_entml_tool_descs
 from echotools.exec.fncall.protocols.entml_think.core import (
     build_entml_thinking_behavior_section,
     build_entml_thinking_meta_section,
 )
-from echotools.exec.fncall.protocols.entml_schema import format_entml_tool_descs
 from echotools.exec.fncall.shared.coercion import _build_param_schema_index
 from echotools.exec.fncall.shared.history_markup import strip_fake_history_markup
 from echotools.exec.fncall.shared.normalization import (
-    normalize_content,
     normalize_tool_calls,
 )
 from echotools.exec.protocol.base import ToolProtocol
@@ -139,7 +135,7 @@ def format_entml_functions_results(
     if not lines:
         return ""
     return (
-        f"<entml:funtions_results>\n"
+        "<entml:funtions_results>\n"
         + "\n".join(lines)
         + "\n</entml:funtions_results>"
     )

{echotools-2.3.99 → echotools-2.3.100}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -19,7 +19,11 @@ from .entml_patterns import (
     split_mangled_json_param_tail,
     synthetic_close_invoke_body,
 )
-from .entml_schema import coerce_entml_arguments, coerce_entml_parameter_value, _coerce_entml_arg_value
+from .entml_schema import (
+    _coerce_entml_arg_value,
+    coerce_entml_arguments,
+    coerce_entml_parameter_value,
+)
 
 
 def _parse_direct_child_tags(

{echotools-2.3.99 → echotools-2.3.100}/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import re
 from typing import Any, Dict, Iterator, List, Optional, Set, Tuple
 
@@ -545,7 +544,10 @@ def strip_tool_entml_residue(
     cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
     return cleaned.strip()
 
-from echotools.exec.fncall.protocols.entml_schema import (
-    mangled_json_param_tail_in_progress,
-    split_mangled_json_param_tail,
-)
+
+# 兼容旧 import 路径（body/invoke/stream 等仍从本模块取 mangled helpers）
+import echotools.exec.fncall.protocols.entml_schema as _entml_schema
+
+mangled_json_param_tail_in_progress = _entml_schema.mangled_json_param_tail_in_progress
+split_mangled_json_param_tail = _entml_schema.split_mangled_json_param_tail
+

{echotools-2.3.99 → echotools-2.3.100}/src/echotools/exec/fncall/protocols/entml_schema.py

@@ -4,7 +4,10 @@ import json
 import re
 from typing import Any, Dict, List, Mapping, Optional, Tuple
 
-from echotools.exec.fncall.shared.coercion import _coerce_param_value, _resolve_effective_type
+from echotools.exec.fncall.shared.coercion import (
+    _coerce_param_value,
+    _resolve_effective_type,
+)
 
 _TYPE_HINT_TO_JSON_TYPE = {
     "str": "string",
@@ -286,48 +289,19 @@ def format_entml_tool_descs(tools: List[Dict[str, Any]]) -> str:
         )
     return "\n\n".join(blocks)
 
-# --- mangled param tail (from entml_patterns) ---
+# --- mangled param tail ---
+#
+# 模型偶发把 schema 尾缀 ``", "description": "...", "timeout": N}}`` 粘进标量 parameter。
+# 通用规则：仅当「从候选起点到 EOS」整段都是该尾缀（可未写完）时才截断；
+# 一旦后续偏离（例如内嵌 JSON 的 ``"method"``），一律视为正文。不依赖参数名黑名单。
 
 _MANGLED_PARAM_JSON_TAIL_RE = re.compile(
     r'"\s*,\s*"description"\s*:\s*"((?:[^"\\]|\\.)*)"\s*,\s*"timeout"\s*:\s*(\d+)\s*\}\}?\s*$',
     re.DOTALL,
 )
-_MANGLED_PARAM_JSON_TAIL_START_RE = re.compile(
-    r'"\s*,\s*"description"\s*:\s*"',
-    re.DOTALL,
-)
-_MANGLED_PARAM_JSON_TAIL_EARLY_RE = re.compile(
-    r'"\s*,\s*"(?:description|timeout)\b',
-    re.DOTALL,
-)
-_MANGLED_PARAM_JSON_TAIL_IN_PROGRESS_RE = re.compile(
-    r'"\s*,\s*"(?:d|t)',
-    re.DOTALL,
-)
-_MANGLED_TAIL_SKIP_PARAM_NAMES = frozenset(
-    {
-        "content",
-        "contents",
-        "text",
-        "body",
-        "file_path",
-        "path",
-        "message",
-        "html",
-        "data",
-        "code",
-    }
-)
 
-
-_MANGLED_PARAM_JSON_COMMA_QUOTE_END_RE = re.compile(
-    r'"\s*,\s*"$',
-    re.DOTALL,
-)
-_MANGLED_PARAM_JSON_COMMA_AFTER_QUOTE_RE = re.compile(
-    r'"\s*,\s*$',
-    re.DOTALL,
-)
+_DESC_KEY = "description"
+_TIMEOUT_KEY = "timeout"
 
 
 def _param_value_is_json_container(value: str) -> bool:
@@ -335,11 +309,156 @@ def _param_value_is_json_container(value: str) -> bool:
     return bool(stripped) and stripped[0] in "{["
 
 
+def _match_schema_key_prefix(
+    text: str,
+    pos: int,
+    *,
+    allowed: Tuple[str, ...] = (_DESC_KEY, _TIMEOUT_KEY),
+) -> Optional[Tuple[str, int]]:
+    """匹配 schema 键。
+
+    返回 ``("<key>"|"partial", new_pos)``；已偏离则 ``None``。
+    """
+    if pos >= len(text):
+        return ("partial", pos)
+    for key in allowed:
+        if text.startswith(key, pos):
+            return (key, pos + len(key))
+    remain = text[pos:]
+    for key in allowed:
+        if key.startswith(remain):
+            return ("partial", len(text))
+    return None
+
+
+def _consume_json_string_body(text: str, pos: int) -> Tuple[int, bool]:
+    """从 JSON 字符串内容起点消费（不含开引号）。返回 ``(new_pos, closed)``。"""
+    i = pos
+    while i < len(text):
+        ch = text[i]
+        if ch == "\\":
+            if i + 1 >= len(text):
+                return len(text), False
+            i += 2
+            continue
+        if ch == '"':
+            return i + 1, True
+        i += 1
+    return len(text), False
+
+
+def _is_mangled_schema_tail_suffix(suffix: str) -> bool:
+    """``suffix`` 是否整段为 mangled schema 尾缀（允许流式未写完）。
+
+    必须以 ``description``（或其真前缀）起头；禁止把文末单独的
+    ``", "timeout": N`` 当成尾缀（避免截断正文 JSON）。
+    """
+    if not suffix:
+        return False
+    m = re.match(r'^"\s*,\s*"', suffix)
+    if not m:
+        return False
+    pos = m.end()
+    # 首键只能是 description（或其真前缀），避免 ", \"t" 误伤 type/timeout 正文
+    key_match = _match_schema_key_prefix(suffix, pos, allowed=(_DESC_KEY,))
+    if key_match is None:
+        return False
+    key, pos = key_match
+    if key == "partial":
+        return pos == len(suffix)
+    if key != _DESC_KEY:
+        return False
+    if pos >= len(suffix):
+        return True
+    if suffix[pos] != '"':
+        return False
+    pos += 1
+    m_colon = re.match(r"\s*:\s*", suffix[pos:])
+    if not m_colon:
+        return bool(re.match(r"\s*$", suffix[pos:]))
+    pos += m_colon.end()
+    if pos >= len(suffix):
+        return True
+    if suffix[pos] != '"':
+        return False
+    pos += 1
+    pos, closed = _consume_json_string_body(suffix, pos)
+    if not closed:
+        return pos == len(suffix)
+    if pos == len(suffix):
+        # description 已闭合、timeout 尚未出现：流式未完成或残缺尾缀，仍视为 mangled
+        return True
+    m_rest = re.match(r"\s*,\s*", suffix[pos:])
+    if not m_rest:
+        return re.match(r"\s*\}{0,2}\s*$", suffix[pos:]) is not None
+    pos += m_rest.end()
+    if pos >= len(suffix):
+        return True
+    if suffix[pos] != '"':
+        return False
+    pos += 1
+    key2 = _match_schema_key_prefix(suffix, pos, allowed=(_TIMEOUT_KEY,))
+    if key2 is None:
+        return False
+    key2_name, pos = key2
+    if key2_name == "partial":
+        return pos == len(suffix)
+    if key2_name != _TIMEOUT_KEY:
+        return False
+    if pos >= len(suffix):
+        return True
+    if suffix[pos] != '"':
+        return False
+    pos += 1
+    m_colon2 = re.match(r"\s*:\s*", suffix[pos:])
+    if not m_colon2:
+        return bool(re.match(r"\s*$", suffix[pos:]))
+    pos += m_colon2.end()
+    m_num2 = re.match(r"\d*", suffix[pos:])
+    assert m_num2 is not None
+    pos += m_num2.end()
+    return re.match(r"\s*\}{0,2}\s*$", suffix[pos:]) is not None
+
+
+def _ambiguous_comma_hold_end(value: str) -> int:
+    """值以 ``",`` / ``", "`` 结尾且下一键未明时，返回应保留到的终点（含引号）。
+
+    流式在键名出现前无法区分 mangled 尾缀与正文 JSON 换键；先截到引号以保持
+    partial_json 单调，待后续字符证明不是 description 后再放出全文。
+    """
+    m = re.search(r'"\s*,\s*"?$', value)
+    if not m:
+        return -1
+    return m.start() + 1
+
+
+def _find_mangled_schema_tail_start(value: str) -> int:
+    """返回 mangled 尾缀起点；无则 -1。
+
+    取最左合法起点，保证一旦出现 ``", "description"...`` 就截在 command 侧，
+    避免流式先发出更长前缀再无法回缩。
+    """
+    starts = [m.start() for m in re.finditer(r'"\s*,\s*"', value)]
+    for start in starts:
+        if _is_mangled_schema_tail_suffix(value[start:]):
+            return start
+    hold = _ambiguous_comma_hold_end(value)
+    if hold >= 0:
+        # 把 hold 点前的引号视为尾缀起点（与合法 mangled 起点同形）
+        return hold - 1
+    return -1
+
+
 def mangled_json_param_tail_in_progress(value: str) -> bool:
-    """parameter 值中出现误写入 JSON 尾缀但尚未收齐时不应继续增长 partial_json。"""
+    """值末尾正在形成 mangled schema 尾缀（尚未收齐）时抑制 partial_json 增长。"""
     if not value or _param_value_is_json_container(value):
         return False
-    return bool(_MANGLED_PARAM_JSON_TAIL_IN_PROGRESS_RE.search(value))
+    start = _find_mangled_schema_tail_start(value)
+    if start < 0:
+        return False
+    if _MANGLED_PARAM_JSON_TAIL_RE.search(value[start:]):
+        return False
+    return True
 
 
 def split_mangled_json_param_tail(
@@ -348,45 +467,27 @@ def split_mangled_json_param_tail(
     param_name: str = "",
 ) -> Tuple[str, Dict[str, Any]]:
     """模型把 ``", "description": ..., "timeout": ...}}`` 误写入 parameter 值时的拆分。"""
+    _ = param_name
     if not value:
         return value, {}
-    if param_name in _MANGLED_TAIL_SKIP_PARAM_NAMES:
-        return value, {}
     if _param_value_is_json_container(value):
         try:
             json.loads(value)
             return value, {}
         except json.JSONDecodeError:
-            # 合法 JSON 数组/对象（含 options.description 等）不得走标量 command 尾缀启发式。
             return value, {}
+
     match = _MANGLED_PARAM_JSON_TAIL_RE.search(value)
     if match:
-        command = value[: match.start() + 1]
-        extra: Dict[str, Any] = {
+        return value[: match.start() + 1], {
             "description": match.group(1),
             "timeout": int(match.group(2)),
         }
-        return command, extra
-    partial = _MANGLED_PARAM_JSON_TAIL_START_RE.search(value)
-    if partial:
-        return value[: partial.start() + 1], {}
-    early = _MANGLED_PARAM_JSON_TAIL_EARLY_RE.search(value)
-    if early:
-        return value[: early.start() + 1], {}
-    inprog = _MANGLED_PARAM_JSON_TAIL_IN_PROGRESS_RE.search(value)
-    if inprog:
-        before = value[: inprog.start()]
-        matches = list(re.finditer(r'"\s*,\s*"', before))
-        if matches:
-            return value[: matches[-1].start() + 1], {}
-        return value[: inprog.start() + 1], {}
-    comma_quote_end = _MANGLED_PARAM_JSON_COMMA_QUOTE_END_RE.search(value)
-    if comma_quote_end:
-        return value[: comma_quote_end.start() + 1], {}
-    comma_after_quote = _MANGLED_PARAM_JSON_COMMA_AFTER_QUOTE_RE.search(value)
-    if comma_after_quote:
-        return value[: comma_after_quote.start() + 1], {}
-    return value, {}
+
+    start = _find_mangled_schema_tail_start(value)
+    if start < 0:
+        return value, {}
+    return value[: start + 1], {}
 
 
 

{echotools-2.3.99 → echotools-2.3.100}/src/echotools/exec/fncall/protocols/entml_stream/snap.py

@@ -15,6 +15,7 @@ from echotools.exec.fncall.protocols.entml_stream.body import (
     _parse_parameter_entries,
 )
 
+
 def _parameters_block_snapshot(
     inner: str,
     *,
@@ -36,7 +37,35 @@ def _parameters_block_snapshot(
     return ""
 
 
-def _collect_streaming_entries(inner: str):
+def build_streaming_json_snapshot(
+    body: str,
+    *,
+    tool_name: str = "",
+    schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]] = None,
+    force_close: bool = False,
+) -> str:
+    """构造当前应已发出的 partial_json 累积串（可未完成）。
+
+    invoke 闭合（或 force_close）时直接走 ``parse_invoke_args``，与批量解析一致。
+    未完成时仅输出合法 JSON 前缀，且不在 ``</entml:invoke>`` 前闭合最外层 ``}``。
+    """
+    invoke_closed = _INVOKE_CLOSE in body
+    inner = body[: body.index(_INVOKE_CLOSE)] if invoke_closed else body
+
+    if invoke_closed or force_close:
+        return _final_invoke_arguments_json(
+            body,
+            tool_name=tool_name,
+            schema_index=schema_index,
+            force_close=force_close,
+        )
+
+    params_snap = _parameters_block_snapshot(
+        inner, tool_name=tool_name, schema_index=schema_index
+    )
+    if params_snap is not None:
+        return params_snap
+
     entries = _parse_parameter_entries(inner)
     seen_keys = {key for key, *_rest in entries}
     for bare in _parse_bare_invoke_entries(inner):
@@ -47,15 +76,9 @@ def _collect_streaming_entries(inner: str):
         if direct[0] not in seen_keys:
             entries.append(direct)
             seen_keys.add(direct[0])
-    return entries
-
+    if not entries:
+        return ""
 
-def _entries_to_json_prefix(
-    entries,
-    *,
-    tool_name: str,
-    schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]],
-) -> str:
     func_schema = (schema_index or {}).get(tool_name) or {}
     parts: List[str] = ["{"]
     for idx, (key, value, is_complete, type_hint) in enumerate(entries):
@@ -69,41 +92,14 @@ def _entries_to_json_prefix(
             value, is_complete, param_type, pschema, type_hint
         )
         if fragment is None:
-            return "" if idx == 0 else "".join(parts)
+            if idx == 0:
+                return ""
+            return "".join(parts)
         parts.append(fragment)
         if not is_complete:
             return "".join(parts)
-    return "".join(parts)
-
 
-def build_streaming_json_snapshot(
-    body: str,
-    *,
-    tool_name: str = "",
-    schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]] = None,
-    force_close: bool = False,
-) -> str:
-    """构造当前应已发出的 partial_json 累积串（可未完成）。"""
-    invoke_closed = _INVOKE_CLOSE in body
-    inner = body[: body.index(_INVOKE_CLOSE)] if invoke_closed else body
-    if invoke_closed or force_close:
-        return _final_invoke_arguments_json(
-            body,
-            tool_name=tool_name,
-            schema_index=schema_index,
-            force_close=force_close,
-        )
-    params_snap = _parameters_block_snapshot(
-        inner, tool_name=tool_name, schema_index=schema_index
-    )
-    if params_snap is not None:
-        return params_snap
-    entries = _collect_streaming_entries(inner)
-    if not entries:
-        return ""
-    return _entries_to_json_prefix(
-        entries, tool_name=tool_name, schema_index=schema_index
-    )
+    return "".join(parts)
 
 
 def _parse_partial_parameter_body(body: str) -> Dict[str, Any]: