test(llm): verify compatibility through requests

Author: elkaix

src/pythinker_code/llm.py

@@ -73,9 +73,9 @@ def capped_chat_provider(llm: LLM, max_output_tokens: int) -> ChatProvider:
     usual output budget (e.g. a context-compaction summary) can use this
     instead of hand-picking a provider-specific kwarg name.
     """
-    compatibility = getattr(llm, "compatibility", None)
-    kwarg = compatibility.output_tokens_kwarg if compatibility is not None else "max_tokens"
-    return cast(Any, llm.chat_provider).with_generation_kwargs(**{kwarg: max_output_tokens})
+    return cast(Any, llm.chat_provider).with_generation_kwargs(
+        **{llm.compatibility.output_tokens_kwarg: max_output_tokens}
+    )
 
 
 def supports_deferred_tool_search(llm: LLM | None) -> bool:
@@ -529,11 +529,10 @@ def available_model_thinking_levels(
 ) -> tuple[ThinkingEffort, ...]:
     """Selectable thinking levels for *model*, scoped to provider-specific support.
 
-    Starts from the capability-derived ladder, then narrows to a provider's
-    actually-accepted set when known (currently the OpenAI GPT-5 family) so the
-    selector never offers — and :func:`create_llm` never sends — a level the
-    model rejects. Falls back to the full ladder for models without a known
-    per-model rule.
+    Starts from the capability-derived ladder, then narrows to the resolved
+    provider/model profile's accepted set when known so the selector never offers —
+    and :func:`create_llm` never sends — a level the model rejects. Falls back to
+    the full ladder for models without a known per-model rule.
     """
     base = available_thinking_levels(capabilities)
     scoped_levels = (

tests/core/test_compaction_overflow.py

@@ -21,7 +21,10 @@
 
 from pythinker_code.config import LLMModel, LLMProvider
 from pythinker_code.llm import LLM, capped_chat_provider
-from pythinker_code.provider_compatibility import resolve_provider_compatibility
+from pythinker_code.provider_compatibility import (
+    default_provider_compatibility,
+    resolve_provider_compatibility,
+)
 from pythinker_code.soul.compaction import SimpleCompaction
 from pythinker_code.wire.types import TextPart
 
@@ -50,7 +53,14 @@ def with_generation_kwargs(self, **kwargs: object) -> _FakeChatProvider:
 
 
 def _fake_llm() -> LLM:
-    return cast(LLM, SimpleNamespace(chat_provider=_FakeChatProvider(), provider_config=None))
+    return cast(
+        LLM,
+        SimpleNamespace(
+            chat_provider=_FakeChatProvider(),
+            provider_config=None,
+            compatibility=default_provider_compatibility(),
+        ),
+    )
 
 
 def _fake_llm_with_provider_type(provider_type: str) -> LLM:

tests/core/test_create_llm.py

@@ -795,20 +795,14 @@ def test_create_llm_zai_glm52_activates_explicit_profile_policy(
     assert llm is not None
     assert isinstance(llm.chat_provider, OpenAILegacy)
     assert llm.compatibility.profile_id == provider_key.removeprefix("managed:")
+    assert llm.compatibility.reasoning_replay_mode == "exact"
+    assert llm.compatibility.auto_reasoning_effort is False
+    assert llm.compatibility.tool_stream is True
+    assert llm.compatibility.tool_message_conversion == "extract_text"
+    assert llm.compatibility.max_output_tokens == 131_072
     assert llm.chat_provider.thinking_effort is None
     assert llm.thinking is True
     assert llm.thinking_effort == "xhigh"
-    assert llm.chat_provider._reasoning_replay_mode == "exact"  # pyright: ignore[reportPrivateUsage]
-    assert llm.chat_provider._auto_reasoning_effort is False  # pyright: ignore[reportPrivateUsage]
-    assert llm.chat_provider._tool_stream is True  # pyright: ignore[reportPrivateUsage]
-    assert llm.chat_provider._tool_message_conversion == "extract_text"  # pyright: ignore[reportPrivateUsage]
-    assert llm.chat_provider._generation_kwargs == {  # pyright: ignore[reportPrivateUsage]
-        "max_tokens": 131_072,
-        "extra_body": {
-            "thinking": {"type": "enabled", "clear_thinking": False},
-            "reasoning_effort": "max",
-        },
-    }
 
 
 @pytest.mark.parametrize(("thinking", "enabled"), [(False, False), (True, True)])
@@ -831,10 +825,10 @@ def test_create_llm_self_hosted_qwen_uses_chat_template_thinking_toggle(
 
     assert llm is not None
     assert isinstance(llm.chat_provider, OpenAILegacy)
+    assert llm.compatibility.profile_id == "qwen-template"
+    assert llm.compatibility.thinking_format == "qwen_template"
     assert llm.chat_provider.thinking_effort is None
-    assert llm.chat_provider._generation_kwargs.get("extra_body") == {  # pyright: ignore[reportPrivateUsage]
-        "chat_template_kwargs": {"enable_thinking": enabled}
-    }
+    assert llm.thinking is enabled
 
 
 def test_create_llm_zai_binary_model_maps_minimal_to_disabled() -> None:
@@ -854,13 +848,11 @@ def test_create_llm_zai_binary_model_maps_minimal_to_disabled() -> None:
 
     assert llm is not None
     assert isinstance(llm.chat_provider, OpenAILegacy)
+    assert llm.compatibility.thinking_format == "zai_binary"
+    assert llm.compatibility.max_output_tokens == 131_072
     assert llm.chat_provider.thinking_effort is None
     assert llm.thinking is False
     assert llm.thinking_effort == "off"
-    assert llm.chat_provider._generation_kwargs == {  # pyright: ignore[reportPrivateUsage]
-        "max_tokens": 131_072,
-        "extra_body": {"thinking": {"type": "disabled"}},
-    }
 
 
 def test_create_llm_local_glm_name_does_not_activate_zai_request_policy() -> None:
@@ -881,8 +873,9 @@ def test_create_llm_local_glm_name_does_not_activate_zai_request_policy() -> Non
     assert llm is not None
     assert isinstance(llm.chat_provider, OpenAILegacy)
     assert llm.compatibility.profile_id == "openai-compatible"
-    assert "extra_body" not in llm.chat_provider._generation_kwargs  # pyright: ignore[reportPrivateUsage]
-    assert "max_tokens" not in llm.chat_provider._generation_kwargs  # pyright: ignore[reportPrivateUsage]
+    assert llm.compatibility.thinking_format == "none"
+    assert llm.compatibility.max_output_tokens is None
+    assert llm.compatibility.tool_stream is False
 
 
 def test_clone_llm_with_model_alias_preserves_kimi_thinking_disabled():

tests/core/test_model_switch_carryover.py

@@ -19,6 +19,7 @@
 
 from pythinker_code.config import Config
 from pythinker_code.llm import LLM
+from pythinker_code.provider_compatibility import default_provider_compatibility
 from pythinker_code.soul.compaction import SimpleCompaction
 from pythinker_code.wire.types import TextPart
 
@@ -31,7 +32,14 @@ def with_generation_kwargs(self, **kwargs: object) -> _FakeChatProvider:
 
 
 def _fake_llm() -> LLM:
-    return cast(LLM, SimpleNamespace(chat_provider=_FakeChatProvider(), provider_config=None))
+    return cast(
+        LLM,
+        SimpleNamespace(
+            chat_provider=_FakeChatProvider(),
+            provider_config=None,
+            compatibility=default_provider_compatibility(),
+        ),
+    )
 
 
 def _history(n_pairs: int = 3) -> list[Message]:

tests/core/test_z_ai_provider_requests.py

@@ -135,6 +135,7 @@ async def test_glm52_request_effort_mapping(
     ("effort", "thinking"),
     [
         ("off", {"type": "disabled"}),
+        ("minimal", {"type": "disabled"}),
         ("high", {"type": "enabled", "clear_thinking": False}),
     ],
 )
@@ -250,6 +251,30 @@ async def test_glm52_exact_replay_does_not_synthesize_missing_reasoning(
     assert body["reasoning_effort"] != "medium"
 
 
+@pytest.mark.parametrize(
+    ("effort", "enabled"),
+    [("off", False), ("high", True)],
+)
+async def test_self_hosted_qwen_uses_chat_template_thinking_toggle(
+    effort: ThinkingEffort,
+    enabled: bool,
+) -> None:
+    body = await _captured_body(
+        route=None,
+        provider_key="local",
+        base_url="http://localhost:8080/v1",
+        model_id="Qwen3.6-35B-A3B",
+        max_context_size=262_144,
+        capabilities={"thinking"},
+        effort=effort,
+        history=[Message(role="user", content="hello")],
+        tools=[],
+    )
+
+    assert body["chat_template_kwargs"] == {"enable_thinking": enabled}
+    assert "reasoning_effort" not in body
+
+
 async def test_local_glm_name_has_no_zai_request_policy() -> None:
     body = await _captured_body(
         route=None,