echotools 2.3.82__tar.gz → 2.3.83__tar.gz

{echotools-2.3.82 → echotools-2.3.83}/PKG-INFO

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

{echotools-2.3.82 → echotools-2.3.83}/pyproject.toml

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

{echotools-2.3.82 → echotools-2.3.83}/src/echotools/exec/fncall/parsers/stream.py

@@ -439,7 +439,7 @@ class FncallStreamParser:
                 else:
                     tail = ""
             else:
-                tail = final if multi else ""
+                tail = ""
             if tail:
                 name = call["function"]["name"]
                 if multi:
@@ -635,10 +635,16 @@ class FncallStreamParser:
             stream_safe_visible_prefix,
         )
 
+        from echotools.exec.fncall.protocols.entml_think.parse import (
+            split_entml_thinking,
+        )
+
         buf = stream_safe_visible_prefix(
             self._raw_buf,
             thinking_enabled=self._thinking_enabled,
         )
+        if self._thinking_enabled and buf:
+            buf, _ = split_entml_thinking(buf, thinking_enabled=True)
         return clean_stream_partial_visible(
             buf,
             has_calls=self.has_calls,
@@ -690,11 +696,6 @@ class FncallStreamParser:
             segment,
             thinking_enabled=self._thinking_enabled,
         )
-        buf = clean_stream_partial_visible(
-            buf,
-            has_calls=self.has_calls,
-            thinking_enabled=self._thinking_enabled,
-        )
         if not buf:
             return ""
         cleaned, _ = strip_fake_history_markup_for_display(buf)
@@ -703,7 +704,11 @@ class FncallStreamParser:
             thinking_enabled=self._thinking_enabled,
             preserve_visible_whitespace=True,
         )
-        return visible
+        return clean_stream_partial_visible(
+            visible,
+            has_calls=self.has_calls,
+            thinking_enabled=self._thinking_enabled,
+        )
 
     def finalize(self) -> Tuple[str, List[Dict[str, Any]]]:
         """结束流式解析，返回 (清理后文本, tool_calls 列表)。幂等。"""

{echotools-2.3.82 → echotools-2.3.83}/src/echotools/exec/fncall/protocols/entml_invoke.py

@@ -15,6 +15,8 @@ from .entml_patterns import (
     extract_parameter_type_attr,
     normalize_entml_name,
     parse_sub_tags,
+    split_mangled_json_param_tail,
+    synthetic_close_invoke_body,
 )
 from .entml_values import coerce_entml_arguments, coerce_entml_parameter_value
 
@@ -58,6 +60,9 @@ def parse_invoke_args(
     schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]],
 ) -> Dict[str, Any]:
     func_props = (schema_index or {}).get(name) or {}
+    if "</entml:invoke>" in body:
+        body = body[: body.index("</entml:invoke>")]
+    body = synthetic_close_invoke_body(body)
 
     params_m = PARAMETERS_RE.search(body)
     if params_m:
@@ -81,6 +86,7 @@ def parse_invoke_args(
             continue
         pname = normalize_entml_name(pname)
         pval = (param_m.group(2) or "").strip()
+        pval, extra = split_mangled_json_param_tail(pval)
         type_hint = extract_parameter_type_attr(attrs)
         pschema = func_props.get(pname) or {}
         args[pname] = coerce_entml_parameter_value(
@@ -88,6 +94,17 @@ def parse_invoke_args(
             pschema or None,
             type_hint=type_hint,
         )
+        for extra_key, extra_val in extra.items():
+            if extra_key in args:
+                continue
+            extra_schema = func_props.get(extra_key) or {}
+            if isinstance(extra_val, (int, float, bool)):
+                args[extra_key] = extra_val
+            else:
+                args[extra_key] = coerce_entml_parameter_value(
+                    str(extra_val),
+                    extra_schema or None,
+                )
 
     _parse_bare_invoke_children(body, args, func_props)
     _parse_direct_child_tags(body, args, func_props)

{echotools-2.3.82 → echotools-2.3.83}/src/echotools/exec/fncall/protocols/entml_patterns.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 from .entml_values import coerce_entml_parameter_value
 
@@ -195,6 +195,92 @@ def _parameter_close_follower_ok(after: str, *, allow_end: bool) -> bool:
     return False
 
 
+_PARAM_OPEN_TAG_RE = re.compile(rf"{PARAM_OPEN_PATTERN}([^>]*)>", re.IGNORECASE)
+_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_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,
+)
+
+
+def mangled_json_param_tail_in_progress(value: str) -> bool:
+    """parameter 值中出现误写入 JSON 尾缀但尚未收齐时不应继续增长 partial_json。"""
+    return bool(value and _MANGLED_PARAM_JSON_TAIL_IN_PROGRESS_RE.search(value))
+
+
+def split_mangled_json_param_tail(value: str) -> Tuple[str, Dict[str, Any]]:
+    """模型把 ``", "description": ..., "timeout": ...}}`` 误写入 parameter 值时的拆分。"""
+    if not value:
+        return value, {}
+    match = _MANGLED_PARAM_JSON_TAIL_RE.search(value)
+    if match:
+        command = value[: match.start() + 1]
+        extra: Dict[str, Any] = {
+            "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], {}
+    if _MANGLED_PARAM_JSON_TAIL_IN_PROGRESS_RE.search(value):
+        matches = list(re.finditer(r'"\s*,\s*"', value))
+        if matches:
+            return value[: matches[-1].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, {}
+
+
+def synthetic_close_invoke_body(inner: str) -> str:
+    """为 force_close / invoke 已闭合但未闭合的 parameter 补齐结构闭合标签。"""
+    if not inner:
+        return inner
+    closed = inner
+    if "<entml:parameters>" in closed and "</entml:parameters>" not in closed:
+        closed = closed + "</entml:parameters>"
+    matches = list(_PARAM_OPEN_TAG_RE.finditer(closed))
+    if matches:
+        last = matches[-1]
+        after = closed[last.end() :]
+        open_snip = closed[last.start() : last.end()].lower()
+        if open_snip.startswith("<parameter") and not open_snip.startswith("<entml:"):
+            need = PARAM_CLOSE_BARE
+        else:
+            need = PARAM_CLOSE_ENTML
+        if need not in after and find_valid_parameter_close(closed, last.end(), allow_end=True) < 0:
+            closed = closed + need
+    return closed
+
+
 def find_valid_parameter_close(body: str, search_from: int = 0, *, allow_end: bool = True) -> int:
     """返回 parameter 闭合标签在 ``body`` 中的起始下标；忽略参数值内的假闭合。"""
     pos = search_from

{echotools-2.3.82 → echotools-2.3.83}/src/echotools/exec/fncall/protocols/entml_stream_json.py

@@ -18,6 +18,8 @@ from .entml_patterns import (
     find_valid_parameter_close,
     normalize_entml_name,
     parameter_close_at,
+    split_mangled_json_param_tail,
+    synthetic_close_invoke_body,
 )
 from .entml_values import coerce_entml_parameter_value
 from echotools.exec.fncall.shared.coercion import _resolve_effective_type
@@ -104,24 +106,8 @@ def _effective_param_type(
 
 
 def _synthetic_close_body(inner: str) -> str:
-    """为 force_close 补齐未闭合的 parameter / parameters 标签。"""
-    if _INVOKE_CLOSE in inner:
-        inner = inner[: inner.index(_INVOKE_CLOSE)]
-    closed = inner
-    if _PARAMETERS_OPEN in closed and _PARAMETERS_CLOSE not in closed:
-        closed = closed + _PARAMETERS_CLOSE
-    matches = list(_PARAM_OPEN_RE.finditer(closed))
-    if matches:
-        last = matches[-1]
-        after = closed[last.end() :]
-        open_snip = closed[last.start() : last.end()].lower()
-        if open_snip.startswith("<parameter") and not open_snip.startswith("<entml:"):
-            need = PARAM_CLOSE_BARE
-        else:
-            need = _PARAM_CLOSE
-        if need not in after and find_valid_parameter_close(closed, last.end(), allow_end=True) < 0:
-            closed = closed + need
-    return closed
+    """兼容旧名；委托 ``synthetic_close_invoke_body``。"""
+    return synthetic_close_invoke_body(inner)
 
 
 def _final_invoke_arguments_json(
@@ -136,7 +122,7 @@ def _final_invoke_arguments_json(
 
     invoke_closed = _INVOKE_CLOSE in body
     inner = body[: body.index(_INVOKE_CLOSE)] if invoke_closed else body
-    parse_body = inner if invoke_closed else _synthetic_close_body(inner)
+    parse_body = synthetic_close_invoke_body(inner)
     args = parse_invoke_args(parse_body, tool_name, schema_index)
     return json.dumps(args, ensure_ascii=False)
 
@@ -312,16 +298,24 @@ def _parse_parameter_entries(body: str) -> List[Tuple[str, str, bool, Optional[s
         val_start = match.end()
         close = _resolve_parameter_close(body, val_start)
         if close < 0:
+            raw = _incomplete_parameter_raw(body, val_start)
+            raw, extra = split_mangled_json_param_tail(raw)
             entries.append(
                 (
                     key,
-                    _incomplete_parameter_raw(body, val_start),
+                    raw,
                     False,
                     type_hint,
                 )
             )
+            for extra_key, extra_val in extra.items():
+                entries.append((extra_key, str(extra_val), True, None))
             break
-        entries.append((key, body[val_start:close].strip(), True, type_hint))
+        raw = body[val_start:close].strip()
+        raw, extra = split_mangled_json_param_tail(raw)
+        entries.append((key, raw, True, type_hint))
+        for extra_key, extra_val in extra.items():
+            entries.append((extra_key, str(extra_val), True, None))
         i = close + parameter_close_at(body, close)
     return entries
 
@@ -467,6 +461,9 @@ class EntmlInvokeJsonStreamEncoder:
                 if a != b:
                     break
                 common += 1
+            if common < len(self._emitted):
+                self._emitted = snapshot
+                return ""
             delta = snapshot[common:]
             self._emitted = snapshot
             return delta

{echotools-2.3.82 → echotools-2.3.83}/src/echotools/exec/fncall/protocols/entml_think/parse.py

@@ -79,6 +79,10 @@ def stream_safe_visible_prefix(
         )
         if open_at >= 0:
             return buf[:open_at]
+    if thinking_enabled:
+        visible, thinking = split_entml_thinking(buf, thinking_enabled=True)
+        if thinking:
+            return visible
     return buf
 
 
@@ -124,8 +128,23 @@ def clean_stream_partial_visible(
     if not text.strip():
         return ""
     if re.search(r"</?entml:", text, re.IGNORECASE):
-        text = re.sub(r"</?entml:[^>]*>", "", text, flags=re.IGNORECASE)
-        text = re.sub(r"</?entml:\w*$", "", text, flags=re.IGNORECASE)
+        if thinking_enabled:
+            # 保留 thinking 标签供 split_entml_thinking 剥离；仅去掉工具相关 entml 残留。
+            text = re.sub(
+                r"</?entml:(?!thinking\b)[^>]*>",
+                "",
+                text,
+                flags=re.IGNORECASE,
+            )
+            text = re.sub(
+                r"</?entml:(?!thinking\b)\w*$",
+                "",
+                text,
+                flags=re.IGNORECASE,
+            )
+        else:
+            text = re.sub(r"</?entml:[^>]*>", "", text, flags=re.IGNORECASE)
+            text = re.sub(r"</?entml:\w*$", "", text, flags=re.IGNORECASE)
         text = text.rstrip()
     return text
 

{echotools-2.3.82 → echotools-2.3.83}/src/echotools/exec/fncall/protocols/entml_tool_blocks.py

@@ -24,6 +24,15 @@ _INNER_TOOL_TAG_RE = re.compile(
     re.IGNORECASE,
 )
 _BRACE_TOOL_HEAD_RE = re.compile(r"\{([A-Za-z][A-Za-z0-9_]*)\s*:\s*")
+# ``{Bash>`` 后接 ``<entml:parameter>`` 的混合格式（``{Edit: json}`` 仍走 history brace）
+_MANGLED_BRACE_ENTML_HEAD_RE = re.compile(
+    r"^\s*\{([A-Za-z][A-Za-z0-9_]*)\s*>\s*",
+    re.MULTILINE,
+)
+_PARAM_MARKER_RE = re.compile(
+    r"<\s*(?:entml:)?parameter\b",
+    re.IGNORECASE,
+)
 # 工具结果常见行号泄漏（Read 伪块）— 仅用于多块 brace 判定
 _OUTPUT_LINE_RE = re.compile(r"^\s*\d+\s+\S", re.MULTILINE)
 _SCALAR_ARG_KEYS = ("path", "command", "pattern", "query", "file_path")
@@ -220,6 +229,30 @@ def _parse_brace_calls(
     return [(name, args)]
 
 
+def _parse_mangled_brace_entml_params(
+    body: str,
+    known: Set[str],
+    schema_index: Optional[Dict[str, Dict[str, Dict[str, Any]]]],
+) -> List[Tuple[str, Dict[str, Any]]]:
+    """``<tool>\\n{Bash>\\n<entml:parameter>...`` 混合格式。"""
+    match = _MANGLED_BRACE_ENTML_HEAD_RE.search(body)
+    if not match:
+        return []
+    name = normalize_entml_name(match.group(1))
+    if known and name not in known:
+        return []
+    rest = body[match.end() :].lstrip()
+    if not _PARAM_MARKER_RE.search(rest):
+        return []
+    from .entml_invoke import parse_invoke_args
+
+    args = parse_invoke_args(rest, name, schema_index)
+    if not args:
+        return []
+    args = coerce_entml_arguments(args, name, schema_index)
+    return [(name, args)]
+
+
 def parse_tool_block_body(
     body: str,
     *,
@@ -237,6 +270,10 @@ def parse_tool_block_body(
     if inner:
         return inner
 
+    mangled = _parse_mangled_brace_entml_params(text, known, schema_index)
+    if mangled:
+        return mangled
+
     if not allow_brace_format:
         return []
 

{echotools-2.3.82 → echotools-2.3.83}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.82 → echotools-2.3.83}/src/tests/test_entml_protocol.py

@@ -1414,3 +1414,52 @@ def test_entml_tool_block_bash_with_output_tail_batch_and_finalize() -> None:
     stream_args = json.loads(stream_calls[0]["function"]["arguments"])
     assert stream_args == batch_args
 
+
+def test_entml_tool_block_mangled_brace_entml_params() -> None:
+    """``<tool>{Bash>\\n<entml:parameter>...`` 混合格式 batch/stream 均解析 Bash。"""
+    from pathlib import Path
+
+    from echotools.exec.fncall.parsers.stream import FncallStreamParser
+
+    sample_path = Path(
+        r"X:/Project/Public/Qwen/logs/responses/req-1785297403-7c656ac5fe40.txt"
+    )
+    if not sample_path.is_file():
+        pytest.skip("corpus file not available")
+    sample = sample_path.read_text(encoding="utf-8")
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "Bash",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "command": {"type": "string"},
+                        "description": {"type": "string"},
+                        "timeout": {"type": "integer"},
+                    },
+                    "required": ["command"],
+                },
+            },
+        }
+    ]
+    clean, batch_calls = get_protocol("entml").parse(sample, tools)
+    assert len(batch_calls) == 1
+    batch_args = json.loads(batch_calls[0]["function"]["arguments"])
+    assert batch_calls[0]["function"]["name"] == "Bash"
+    assert "alicdn-analytics" in batch_args["command"]
+    assert batch_args.get("timeout") == 30
+    assert "RC4" in clean
+
+    for chunk in (1, 17, 64):
+        parser = FncallStreamParser(protocol=get_protocol("entml"), tools=tools)
+        for i in range(0, len(sample), chunk):
+            parser.feed(sample[i : i + chunk])
+        stream_clean, stream_calls = parser.finalize()
+        assert len(stream_calls) == 1, f"chunk={chunk}"
+        stream_args = json.loads(stream_calls[0]["function"]["arguments"])
+        assert stream_args == batch_args, f"chunk={chunk}"
+        assert len(parser.partial_thinking) > 100, f"chunk={chunk}"
+        assert "RC4" in stream_clean or "RC4" in parser.partial_text, f"chunk={chunk}"
+

{echotools-2.3.82 → echotools-2.3.83}/src/tests/test_fncall_stream_thinking.py

@@ -90,6 +90,59 @@ def test_thinking_close_and_invoke_in_one_chunk() -> None:
     assert "reason" not in clean or clean.strip() == ""
 
 
+def test_thinking_close_does_not_leak_into_partial_text() -> None:
+    """thinking 闭合后 partial_text 不得重复输出思考正文（Rogator text/reasoning 双发）。"""
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    thinking_body = (
+        "The concurrent test shows SSE received 0 bytes even though BidiAppend returned 200.\n"
+        "Default reply language: Simplified Chinese\n"
+    )
+    answer = "并发测试显示SSE线程收到状态200但0字节数据。"
+    text = (
+        f"<entml:thinking>\n{thinking_body}</entml:thinking>\n\n{answer}\n{INVOKE}"
+    )
+    dup_count = 0
+    for i in range(0, len(text), 17):
+        parser.feed(text[i : i + 17])
+        pt = parser.partial_text
+        pth = parser.partial_thinking
+        if pth and thinking_body[:40] in pt:
+            dup_count += 1
+    clean, calls = parser.finalize()
+    assert dup_count == 0, "thinking body leaked into partial_text during stream"
+    assert thinking_body.strip() in parser.partial_thinking
+    assert "The concurrent test shows" not in clean
+    assert answer in clean
+    assert len(calls) == 1
+
+
+@pytest.mark.parametrize("chunk", [1, 17, 64])
+def test_thinking_then_answer_no_partial_text_dup(chunk: int) -> None:
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    text = (
+        "<entml:thinking>\nlong reasoning line one\nline two\n</entml:thinking>\n"
+        "visible answer\n"
+        f"{INVOKE}"
+    )
+    for i in range(0, len(text), chunk):
+        parser.feed(text[i : i + chunk])
+        assert "long reasoning" not in parser.partial_text
+    clean, calls = parser.finalize()
+    assert "long reasoning" in parser.partial_thinking
+    assert "visible answer" in clean
+    assert "long reasoning" not in clean
+
+
+    parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
+    chunks = ["<entml:thinking>reason</entml:thinking>", INVOKE]
+    for chunk in chunks:
+        parser.feed(chunk)
+    clean, calls = parser.finalize()
+    assert parser.partial_thinking.strip() == "reason"
+    assert len(calls) == 1
+    assert "reason" not in clean or clean.strip() == ""
+
+
 def test_no_thinking_invoke_still_works() -> None:
     parser = FncallStreamParser(protocol=get_protocol("entml"), tools=TOOLS)
     parser.feed(f"Sure.\n{INVOKE}")

{echotools-2.3.82 → echotools-2.3.83}/src/tests/test_stream_partial_json_parity.py

@@ -139,6 +139,57 @@ def test_read_anyof_integer_stream_json_buf_matches_batch() -> None:
     }
 
 
+BASH_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "Bash",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string"},
+                    "description": {"type": "string"},
+                    "timeout": {"type": "integer"},
+                },
+                "required": ["command"],
+            },
+        },
+    }
+]
+
+
+def test_mangled_json_tail_in_command_param_batch_and_stream() -> None:
+    """未闭合 parameter + JSON 尾缀误写入 command：batch/stream json_buf 须可解析且一致。"""
+    from pathlib import Path
+
+    text = Path(
+        r"X:/Project/Public/Qwen/logs/responses/req-1785296513-7782eb161d4d.txt"
+    ).read_text(encoding="utf-8")
+    proto = get_protocol("entml")
+    batch_args = json.loads(proto.parse(text, BASH_TOOLS)[1][0]["function"]["arguments"])
+    assert "command" in batch_args
+    assert batch_args["command"].endswith("head -60\"")
+    assert "description" not in batch_args["command"]
+    assert batch_args.get("description")
+    assert batch_args.get("timeout") == 30000
+
+    for chunk in (1, 17, 64):
+        parser = FncallStreamParser(protocol=proto, tools=BASH_TOOLS)
+        json_buf = ""
+        for i in range(0, len(text), chunk):
+            parser.feed(text[i : i + chunk])
+            while True:
+                delta = parser.consume_stream_delta()
+                if not delta:
+                    break
+                json_buf += delta[1]
+        comp = parser.complete_stream_delta_if_needed()
+        if comp:
+            json_buf += comp[1]
+        parser.finalize()
+        assert json.loads(json_buf) == batch_args, f"chunk={chunk}"
+
+
 def test_parameters_block_no_stream_until_closed() -> None:
     body = (
         "<entml:parameters>\n"