echotools 2.3.21__tar.gz → 2.3.22__tar.gz

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

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

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

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

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

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

{echotools-2.3.21 → 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.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"