echotools 2.3.19__tar.gz → 2.3.22__tar.gz

{echotools-2.3.19 → echotools-2.3.22}/PKG-INFO

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

{echotools-2.3.19 → echotools-2.3.22}/pyproject.toml

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

{echotools-2.3.19 → echotools-2.3.22}/src/echotools/exec/fncall/protocols/entml_thinking.py

@@ -47,9 +47,23 @@ def normalize_thinking_mode(mode: Any) -> Optional[str]:
     return None
 
 
+def parse_max_thinking_length(value: Any) -> Optional[int]:
+    """仅当显式传入正整数时返回长度；否则为 None（不注入标签）。"""
+    if value is None:
+        return None
+    if isinstance(value, str) and not value.strip():
+        return None
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return None
+    if parsed <= 0:
+        return None
+    return parsed
+
+
 def _policy_header(mode: str) -> str:
     labels = {
-        "off": "off (forced no thinking)",
         "on": "on (forced thinking)",
         "auto": "auto (model decides)",
     }
@@ -59,17 +73,6 @@ def _policy_header(mode: str) -> str:
     )
 
 
-def _prompt_off() -> list[str]:
-    return [
-        _policy_header("off"),
-        "",
-        "You must NOT output any thinking blocks in this response.",
-        f"Do not write `{_THINKING_BLOCK_OPEN}` or `{_THINKING_BLOCK_CLOSE}`.",
-        "Respond with only the visible answer text and any "
-        "`<entml:function_calls>` blocks if tools are needed.",
-    ]
-
-
 def _prompt_on() -> list[str]:
     return [
         _policy_header("on"),
@@ -115,10 +118,13 @@ def _prompt_auto() -> list[str]:
 def build_entml_thinking_section(
     protocol_options: Optional[Dict[str, Any]] = None,
 ) -> str:
-    """按 thinking_mode 构建思考链指令块（off / on / auto 三套 prompt）。"""
+    """按 thinking_mode 构建思考链指令块（on / auto）；off 时不注入任何内容。"""
     opts = protocol_options or {}
     mode = normalize_thinking_mode(opts.get("thinking_mode"))
-    max_thinking_length = opts.get("max_thinking_length")
+    max_thinking_length = parse_max_thinking_length(opts.get("max_thinking_length"))
+
+    if mode == "off":
+        return ""
 
     if mode is None and max_thinking_length is None:
         return ""
@@ -128,12 +134,10 @@ def build_entml_thinking_section(
         lines.append(f"<entml:thinking_mode>{mode}</entml:thinking_mode>")
     if max_thinking_length is not None:
         lines.append(
-            f"<entml:max_thinking_length>{int(max_thinking_length)}</entml:max_thinking_length>"
+            f"<entml:max_thinking_length>{max_thinking_length}</entml:max_thinking_length>"
         )
 
-    if mode == "off":
-        lines.extend([""] + _prompt_off())
-    elif mode == "on":
+    if mode == "on":
         lines.extend([""] + _prompt_on())
     elif mode == "auto":
         lines.extend([""] + _prompt_auto())

echotools-2.3.22/src/echotools/exec/fncall/protocols/entml_thinking_history.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Mapping, Optional
+
+REASONING_KEYS = ("reasoning", "reasoning_content", "reasoning_details")
+HISTORY_FLAG_KEYS = (
+    "include_thinking_in_history",
+    "pass_thinking",
+    "include_thinking",
+    "interleaved_history",
+)
+_THINKING_BLOCK_TYPES = frozenset({"thinking", "reasoning", "redacted_thinking"})
+
+
+def parse_interleaved_history(
+    body: Mapping[str, Any],
+    extra: Optional[Mapping[str, Any]] = None,
+    thinking: Any = None,
+) -> bool:
+    """解析是否将历史 assistant 思考链传给模型（Entropy interleaved_history）。"""
+    extra = extra or {}
+    if thinking is None:
+        thinking = body.get("thinking")
+    for key in ("interleaved_history", "include_in_history"):
+        if key in body:
+            return bool(body[key])
+        if key in extra:
+            return bool(extra[key])
+    if isinstance(thinking, dict):
+        for key in ("interleaved_history", "include_in_history"):
+            if key in thinking:
+                return bool(thinking[key])
+    return False
+
+
+def _thinking_from_content_block(block: Any) -> str:
+    if not isinstance(block, dict):
+        return ""
+    btype = str(block.get("type", "")).strip().lower()
+    if btype in ("thinking", "redacted_thinking"):
+        val = block.get("thinking") or block.get("data")
+        return str(val).strip() if val else ""
+    if btype == "reasoning":
+        val = block.get("text") or block.get("reasoning")
+        return str(val).strip() if val else ""
+    return ""
+
+
+def extract_reasoning_text(msg: Mapping[str, Any]) -> str:
+    """从 assistant 消息字段或 Entropy/Anthropic 内容块提取思考文本。"""
+    for key in ("reasoning", "reasoning_content"):
+        val = msg.get(key)
+        if isinstance(val, str) and val.strip():
+            return val.strip()
+
+    details = msg.get("reasoning_details")
+    if isinstance(details, list):
+        parts: List[str] = []
+        for item in details:
+            if not isinstance(item, dict):
+                continue
+            text = item.get("text")
+            if text:
+                parts.append(str(text))
+        if parts:
+            return "".join(parts)
+
+    content = msg.get("content")
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            text = _thinking_from_content_block(block)
+            if text:
+                parts.append(text)
+        if parts:
+            return "\n".join(parts)
+    return ""
+
+
+def _strip_thinking_blocks(content: List[Any]) -> List[Any]:
+    kept: List[Any] = []
+    for block in content:
+        if isinstance(block, dict) and str(block.get("type", "")).lower() in _THINKING_BLOCK_TYPES:
+            continue
+        kept.append(block)
+    return kept
+
+
+def _collapse_text_content(blocks: List[Any]) -> Any:
+    if len(blocks) == 1:
+        only = blocks[0]
+        if isinstance(only, dict) and only.get("type") == "text":
+            return only.get("text", "")
+    return blocks
+
+
+def _strip_reasoning_from_message(msg: Dict[str, Any]) -> Dict[str, Any]:
+    out = dict(msg)
+    for key in REASONING_KEYS:
+        out.pop(key, None)
+    content = out.get("content")
+    if isinstance(content, list):
+        stripped = _strip_thinking_blocks(content)
+        out["content"] = _collapse_text_content(stripped) if stripped else ""
+    return out
+
+
+def _normalize_message_with_reasoning(msg: Dict[str, Any]) -> Dict[str, Any]:
+    out = dict(msg)
+    if out.get("role") != "assistant":
+        for key in REASONING_KEYS:
+            out.pop(key, None)
+        return out
+
+    text = extract_reasoning_text(out)
+    if text:
+        out["reasoning"] = text
+        out.setdefault("reasoning_content", text)
+    return out
+
+
+def apply_thinking_history_policy(
+    messages: List[Dict[str, Any]],
+    include: bool,
+) -> List[Dict[str, Any]]:
+    """按 interleaved_history 保留或剥离历史思考链。
+
+    include=True: 保留 reasoning 字段与 content 中的 thinking 块。
+    include=False: 仅保留可见回复，剥离思考链。
+    """
+    if include:
+        return [_normalize_message_with_reasoning(dict(m)) for m in messages]
+    return [_strip_reasoning_from_message(dict(m)) for m in messages]

{echotools-2.3.19 → echotools-2.3.22}/src/echotools.egg-info/PKG-INFO

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

{echotools-2.3.19 → echotools-2.3.22}/src/echotools.egg-info/SOURCES.txt

@@ -58,6 +58,7 @@ src/echotools/exec/fncall/protocols/entml.py
 src/echotools/exec/fncall/protocols/entml_invoke.py
 src/echotools/exec/fncall/protocols/entml_patterns.py
 src/echotools/exec/fncall/protocols/entml_thinking.py
+src/echotools/exec/fncall/protocols/entml_thinking_history.py
 src/echotools/exec/fncall/protocols/entml_thinking_parse.py
 src/echotools/exec/fncall/protocols/entml_tools.py
 src/echotools/exec/fncall/protocols/entml_values.py
@@ -151,6 +152,7 @@ src/tests/test_dispatch.py
 src/tests/test_dispatch_extended.py
 src/tests/test_dispatch_race.py
 src/tests/test_entml_protocol.py
+src/tests/test_entml_thinking_history.py
 src/tests/test_entml_thinking_parse.py
 src/tests/test_entml_tools.py
 src/tests/test_errors.py

{echotools-2.3.19 → echotools-2.3.22}/src/tests/test_entml_protocol.py

@@ -72,6 +72,17 @@ def test_build_entml_thinking_section_empty_without_options() -> None:
     assert build_entml_thinking_section({}) == ""
 
 
+def test_parse_max_thinking_length() -> None:
+    from echotools.exec.fncall.protocols.entml_thinking import parse_max_thinking_length
+
+    assert parse_max_thinking_length(None) is None
+    assert parse_max_thinking_length("") is None
+    assert parse_max_thinking_length("  ") is None
+    assert parse_max_thinking_length(0) is None
+    assert parse_max_thinking_length(22000) == 22000
+    assert parse_max_thinking_length("22000") == 22000
+
+
 @pytest.mark.parametrize(
     "raw,expected",
     [
@@ -90,11 +101,16 @@ def test_normalize_thinking_mode(raw, expected) -> None:
 
 
 def test_thinking_prompt_off() -> None:
-    section = build_entml_thinking_section({"thinking_mode": "off"})
-    assert "<entml:thinking_mode>off</entml:thinking_mode>" in section
-    assert "forced no thinking" in section
-    assert "You must NOT output any thinking blocks" in section
-    assert "MUST output a thinking block" not in section
+    assert build_entml_thinking_section({"thinking_mode": "off"}) == ""
+    assert build_entml_thinking_section(
+        {"thinking_mode": "off", "max_thinking_length": 22000}
+    ) == ""
+
+
+def test_thinking_prompt_on_without_max_length() -> None:
+    section = build_entml_thinking_section({"thinking_mode": "on"})
+    assert "<entml:thinking_mode>on</entml:thinking_mode>" in section
+    assert "<entml:max_thinking_length>" not in section
 
 
 def test_thinking_prompt_on() -> None:
@@ -124,8 +140,9 @@ def test_inject_no_tools_with_thinking_off() -> None:
         proto,
         protocol_options={"thinking_mode": "off"},
     )[0]["content"]
-    assert "<entml:thinking_mode>off</entml:thinking_mode>" in result
-    assert "You must NOT output any thinking blocks" in result
+    assert "<entml:thinking_mode>" not in result
+    assert "<entml:max_thinking_length>" not in result
+    assert "You must NOT output any thinking blocks" not in result
     assert "<current_user_message>\nhi\n</current_user_message>" in result
 
 

echotools-2.3.22/src/tests/test_entml_thinking_history.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from echotools.exec.fncall.protocols.entml_thinking_history import (
+    apply_thinking_history_policy,
+    extract_reasoning_text,
+    parse_interleaved_history,
+)
+
+
+def test_parse_interleaved_history_from_thinking_object() -> None:
+    body = {"thinking": {"mode": "on", "interleaved_history": True}}
+    assert parse_interleaved_history(body) is True
+    assert parse_interleaved_history({"thinking": {"interleaved_history": False}}) is False
+
+
+def test_parse_interleaved_history_top_level() -> None:
+    assert parse_interleaved_history({"interleaved_history": True}) is True
+    assert parse_interleaved_history({}, extra={"interleaved_history": True}) is True
+
+
+def test_strip_reasoning_fields_when_disabled() -> None:
+    msgs = [
+        {
+            "role": "assistant",
+            "content": "answer",
+            "reasoning": "thought",
+            "reasoning_content": "thought",
+        }
+    ]
+    out = apply_thinking_history_policy(msgs, False)
+    assert out[0]["content"] == "answer"
+    assert "reasoning" not in out[0]
+
+
+def test_strip_entropy_thinking_blocks_when_disabled() -> None:
+    msgs = [
+        {
+            "role": "assistant",
+            "content": [
+                {"type": "thinking", "thinking": "step 1"},
+                {"type": "text", "text": "hello"},
+            ],
+        }
+    ]
+    out = apply_thinking_history_policy(msgs, False)
+    assert out[0]["content"] == "hello"
+    assert "reasoning" not in out[0]
+
+
+def test_preserve_entropy_thinking_blocks_when_enabled() -> None:
+    msgs = [
+        {
+            "role": "assistant",
+            "content": [
+                {"type": "thinking", "thinking": "step 1"},
+                {"type": "text", "text": "hello"},
+            ],
+        }
+    ]
+    out = apply_thinking_history_policy(msgs, True)
+    assert out[0]["reasoning"] == "step 1"
+    assert out[0]["reasoning_content"] == "step 1"
+    assert out[0]["content"][0]["type"] == "thinking"
+
+
+def test_extract_reasoning_text_from_blocks() -> None:
+    msg = {
+        "role": "assistant",
+        "content": [{"type": "thinking", "thinking": "a"}, {"type": "text", "text": "b"}],
+    }
+    assert extract_reasoning_text(msg) == "a"