echotools 2.3.16__tar.gz → 2.3.19__tar.gz

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

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

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

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

{echotools-2.3.16 → echotools-2.3.19}/src/echotools/exec/fncall/prompt/inject.py

@@ -21,6 +21,7 @@ from echotools.exec.fncall.protocols.entml import (
     format_entml_conversation_history,
     format_entml_current_user_message,
 )
+from echotools.exec.fncall.protocols.entml_thinking import build_entml_thinking_section
 from echotools.exec.fncall.shared.loop_detect import detect_tool_loop
 from echotools.exec.fncall.shared.normalization import format_tool_descs
 from echotools.exec.protocol.base import ToolProtocol
@@ -108,12 +109,17 @@ def inject_fncall(
     if not tools:
         if protocol.id == "entml":
             sections: List[str] = []
+            thinking_section = build_entml_thinking_section(protocol_options)
+            if thinking_section:
+                sections.append(thinking_section)
             if history_text.strip():
                 sections.append(format_entml_conversation_history(history_text))
             sections.append(format_entml_current_user_message(current_user_message))
             prompt = "\n\n".join(sections)
         else:
             prompt = build_no_tools_prompt(history_text, current_user_message)
+        if dump_prompt:
+            _maybe_dump_prompt(prompt, dump_dir)
         return [{"role": "user", "content": prompt}]
 
     prompt = build_tools_prompt(

echotools-2.3.19/src/echotools/exec/fncall/protocols/entml_thinking.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+_CANONICAL_MODES = frozenset({"off", "on", "auto"})
+
+_OFF_ALIASES = frozenset(
+    {"off", "disabled", "disable", "false", "none", "no", "never"}
+)
+_ON_ALIASES = frozenset(
+    {
+        "on",
+        "enabled",
+        "enable",
+        "true",
+        "force",
+        "forced",
+        "required",
+        "must",
+        "static",
+        "thinking",
+    }
+)
+_AUTO_ALIASES = frozenset(
+    {"auto", "automatic", "adaptive", "interleaved"}
+)
+
+_THINKING_BLOCK_OPEN = "<entml:thinking>"
+_THINKING_BLOCK_CLOSE = "</entml:thinking>"
+
+
+def normalize_thinking_mode(mode: Any) -> Optional[str]:
+    """将外界声明归一化为 off | on | auto；无法识别时返回 None。"""
+    if mode is None:
+        return None
+    key = str(mode).strip().lower()
+    if not key:
+        return None
+    if key in _OFF_ALIASES:
+        return "off"
+    if key in _ON_ALIASES:
+        return "on"
+    if key in _AUTO_ALIASES:
+        return "auto"
+    if key in _CANONICAL_MODES:
+        return key
+    return None
+
+
+def _policy_header(mode: str) -> str:
+    labels = {
+        "off": "off (forced no thinking)",
+        "on": "on (forced thinking)",
+        "auto": "auto (model decides)",
+    }
+    return (
+        f"The thinking_mode for this request is {labels[mode]}. "
+        f"Follow the rules below exactly."
+    )
+
+
+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"),
+        "",
+        "You MUST output a thinking block before any other content.",
+        "At the very start of your response, output:",
+        "",
+        _THINKING_BLOCK_OPEN,
+        "...your reasoning here...",
+        _THINKING_BLOCK_CLOSE,
+        "",
+        "Only after that block, output your visible reply and/or "
+        "`<entml:function_calls>`. Never skip the thinking block.",
+    ]
+
+
+def _prompt_auto() -> list[str]:
+    return [
+        _policy_header("auto"),
+        "",
+        "Thinking blocks are optional but encouraged when they would help.",
+        "At the very start of your response, think carefully about whether "
+        f"a `{_THINKING_BLOCK_OPEN}` `{_THINKING_BLOCK_CLOSE}` block would be "
+        "appropriate and strongly prefer to output one if you are uncertain.",
+        "",
+        "After function results, you should strongly consider outputting a "
+        "thinking block before continuing. Example:",
+        "",
+        "<entml:function_calls>",
+        "...",
+        "</entml:function_calls>",
+        "",
+        "<function_results>",
+        "...",
+        "</function_results>",
+        "",
+        _THINKING_BLOCK_OPEN,
+        "...thinking about results...",
+        _THINKING_BLOCK_CLOSE,
+    ]
+
+
+def build_entml_thinking_section(
+    protocol_options: Optional[Dict[str, Any]] = None,
+) -> str:
+    """按 thinking_mode 构建思考链指令块（off / on / auto 三套 prompt）。"""
+    opts = protocol_options or {}
+    mode = normalize_thinking_mode(opts.get("thinking_mode"))
+    max_thinking_length = opts.get("max_thinking_length")
+
+    if mode is None and max_thinking_length is None:
+        return ""
+
+    lines: list[str] = []
+    if mode is not None:
+        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>"
+        )
+
+    if mode == "off":
+        lines.extend([""] + _prompt_off())
+    elif mode == "on":
+        lines.extend([""] + _prompt_on())
+    elif mode == "auto":
+        lines.extend([""] + _prompt_auto())
+
+    return "\n".join(lines)

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

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

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

@@ -6,7 +6,10 @@ import pytest
 
 from echotools.exec.fncall import get_protocol, inject_fncall
 from echotools.exec.fncall.protocols.entml_invoke import parse_entml_tool_calls
-from echotools.exec.fncall.protocols.entml_thinking import build_entml_thinking_section
+from echotools.exec.fncall.protocols.entml_thinking import (
+    build_entml_thinking_section,
+    normalize_thinking_mode,
+)
 from echotools.exec.fncall.protocols.entml_values import coerce_entml_parameter_value
 from echotools.exec.fncall.shared.coercion import _build_param_schema_index
 
@@ -54,13 +57,13 @@ def test_inject_with_thinking_options_only_when_declared() -> None:
         tools,
         proto,
         protocol_options={
-            "thinking_mode": "interleaved",
+            "thinking_mode": "on",
             "max_thinking_length": 22000,
         },
     )[0]["content"]
-    assert "<entml:thinking_mode>interleaved</entml:thinking_mode>" in with_opts
+    assert "<entml:thinking_mode>on</entml:thinking_mode>" in with_opts
     assert "<entml:max_thinking_length>22000</entml:max_thinking_length>" in with_opts
-    assert "<entml:thinking>" in with_opts
+    assert "MUST output a thinking block" in with_opts
     assert "At the very start of your response" in with_opts
 
 
@@ -69,6 +72,76 @@ def test_build_entml_thinking_section_empty_without_options() -> None:
     assert build_entml_thinking_section({}) == ""
 
 
+@pytest.mark.parametrize(
+    "raw,expected",
+    [
+        ("off", "off"),
+        ("disabled", "off"),
+        ("on", "on"),
+        ("enabled", "on"),
+        ("interleaved", "auto"),
+        ("auto", "auto"),
+        ("adaptive", "auto"),
+        ("bogus", None),
+    ],
+)
+def test_normalize_thinking_mode(raw, expected) -> None:
+    assert normalize_thinking_mode(raw) == expected
+
+
+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
+
+
+def test_thinking_prompt_on() -> None:
+    section = build_entml_thinking_section({"thinking_mode": "on"})
+    assert "<entml:thinking_mode>on</entml:thinking_mode>" in section
+    assert "forced thinking" in section
+    assert "MUST output a thinking block" in section
+    assert "<entml:thinking>" in section
+    assert "You must NOT output any thinking blocks" not in section
+
+
+def test_thinking_prompt_auto() -> None:
+    section = build_entml_thinking_section({"thinking_mode": "auto"})
+    assert "<entml:thinking_mode>auto</entml:thinking_mode>" in section
+    assert "model decides" in section
+    assert "<function_results>" in section
+    assert "strongly prefer to output one if you are uncertain" in section
+    assert "MUST output a thinking block" not in section
+
+
+def test_inject_no_tools_with_thinking_off() -> None:
+    proto = get_protocol("entml")
+    msgs = [{"role": "user", "content": "hi"}]
+    result = inject_fncall(
+        msgs,
+        [],
+        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 "<current_user_message>\nhi\n</current_user_message>" in result
+
+
+def test_inject_no_tools_with_thinking_on() -> None:
+    proto = get_protocol("entml")
+    msgs = [{"role": "user", "content": "hi"}]
+    result = inject_fncall(
+        msgs,
+        [],
+        proto,
+        protocol_options={"thinking_mode": "on"},
+    )[0]["content"]
+    assert "<entml:thinking_mode>on</entml:thinking_mode>" in result
+    assert "MUST output a thinking block" in result
+
+
 def test_inject_with_history_entml_tags() -> None:
     proto = get_protocol("entml")
     tools = [
@@ -167,7 +240,7 @@ def test_entml_instruction_matches_spec_format() -> None:
         lang="en",
         current_user_message="pick one",
         protocol_options={
-            "thinking_mode": "interleaved",
+            "thinking_mode": "on",
             "max_thinking_length": 22000,
         },
     )
@@ -179,9 +252,10 @@ def test_entml_instruction_matches_spec_format() -> None:
     assert '<entml:invoke name="$FUNCTION_NAME">' in prompt
     assert '<entml:parameter name="$PARAMETER_NAME">' in prompt
     assert "String and scalar parameters should be specified as is" in prompt
-    assert "<entml:thinking_mode>interleaved</entml:thinking_mode>" in prompt
+    assert "<entml:thinking_mode>on</entml:thinking_mode>" in prompt
     assert "<entml:max_thinking_length>22000</entml:max_thinking_length>" in prompt
-    assert "<function_results>" in prompt
+    assert "MUST output a thinking block" in prompt
+    assert "<function_results>" not in prompt
     assert "<entml:conversation_history>" not in prompt
     assert "<entml:history>" not in prompt
     assert "<functions>" not in prompt

echotools-2.3.16/src/echotools/exec/fncall/protocols/entml_thinking.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-
-def build_entml_thinking_section(
-    protocol_options: Optional[Dict[str, Any]] = None,
-) -> str:
-    """仅当外界声明 thinking_mode / max_thinking_length 时构建思考链指令块。"""
-    opts = protocol_options or {}
-    thinking_mode = opts.get("thinking_mode")
-    max_thinking_length = opts.get("max_thinking_length")
-
-    if thinking_mode is None and max_thinking_length is None:
-        return ""
-
-    lines: list[str] = []
-    if thinking_mode is not None:
-        mode = str(thinking_mode).strip()
-        if mode:
-            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>"
-        )
-
-    mode_lower = str(thinking_mode or "").strip().lower()
-    if mode_lower in ("interleaved", "auto"):
-        lines.extend(
-            [
-                "",
-                "If the thinking_mode is interleaved or auto, then after function "
-                "results you should strongly consider outputting a thinking block. "
-                "Here is an example:",
-                "",
-                "<entml:function_calls>",
-                "...",
-                "</entml:function_calls>",
-                "",
-                "<function_results>",
-                "...",
-                "</function_results>",
-                "",
-                "<entml:thinking>",
-                "...thinking about results",
-                "</entml:thinking>",
-                "At the very start of your response, think carefully about whether "
-                "an `<entml:thinking>` `</entml:thinking>` block would be appropriate "
-                "and strongly prefer to output a thinking block if you are uncertain.",
-            ]
-        )
-
-    return "\n".join(lines)