Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

5.7 KB
Raw Blame
"""Tests for the centralized reasoning-effort registry."""

from __future__ import annotations

import pytest

from deeptutor.services.llm.reasoning_params import (
    build_openai_compatible_reasoning_kwargs,
    default_reasoning_effort_for,
)


class TestDefaultReasoningEffortFor:
    """Single source of truth for the implicit per-provider/model effort."""

    @pytest.mark.parametrize(
        "model, expected",
        [
            ("gemini-2.5-flash", "none"),
            ("gemini-2.5-flash-lite", "none"),
            ("GEMINI-2.5-FLASH", "none"),
            ("models/gemini-2.5-flash", "none"),
            ("gemini-2.5-pro", "minimal"),
            ("gemini-3.0-pro", "minimal"),
            ("gemini-3.6-flash", "minimal"),
            ("gemini-3.6-flash-latest", "minimal"),
            ("models/gemini-3.6-flash", "minimal"),
        ],
    )
    def test_gemini_thinking_models_default(self, model: str, expected: str) -> None:
        assert default_reasoning_effort_for("gemini", model) == expected

    @pytest.mark.parametrize(
        "model",
        ["gemini-1.5-flash", "gemini-1.5-pro", "gemini-2.0-flash"],
    )
    def test_gemini_legacy_models_unaffected(self, model: str) -> None:
        assert default_reasoning_effort_for("gemini", model) is None

    def test_other_providers_unaffected(self) -> None:
        assert default_reasoning_effort_for("openai", "gpt-5") is None
        assert default_reasoning_effort_for("deepseek", "deepseek-v4") is None
        assert default_reasoning_effort_for("dashscope", "qwen3-max") is None

    def test_missing_provider_or_model(self) -> None:
        assert default_reasoning_effort_for(None, "gemini-2.5-flash") is None
        assert default_reasoning_effort_for("gemini", None) is None
        assert default_reasoning_effort_for("", "") is None

    def test_provider_name_case_insensitive(self) -> None:
        assert default_reasoning_effort_for("Gemini", "gemini-2.5-flash") == "none"
        assert default_reasoning_effort_for("GEMINI", "gemini-2.5-flash") == "none"


class TestBuildOpenAICompatibleReasoningKwargsForGemini:
    """The OpenAI-compat helper consults the same registry."""

    def test_gemini_25_defaults_off_when_unspecified(self) -> None:
        kwargs = build_openai_compatible_reasoning_kwargs(
            spec=None, binding="gemini", model="gemini-2.5-flash", reasoning_effort=None
        )
        assert kwargs == {"reasoning_effort": "none"}

    def test_models_prefix_still_matches(self) -> None:
        kwargs = build_openai_compatible_reasoning_kwargs(
            spec=None,
            binding="gemini",
            model="models/gemini-2.5-flash",
            reasoning_effort=None,
        )
        assert kwargs == {"reasoning_effort": "none"}

    def test_explicit_effort_takes_precedence(self) -> None:
        kwargs = build_openai_compatible_reasoning_kwargs(
            spec=None,
            binding="gemini",
            model="gemini-2.5-flash",
            reasoning_effort="high",
        )
        assert kwargs == {"reasoning_effort": "high"}

    def test_gemini_15_left_untouched(self) -> None:
        kwargs = build_openai_compatible_reasoning_kwargs(
            spec=None,
            binding="gemini",
            model="gemini-1.5-flash",
            reasoning_effort=None,
        )
        assert kwargs == {}

    def test_openai_left_untouched(self) -> None:
        kwargs = build_openai_compatible_reasoning_kwargs(
            spec=None, binding="openai", model="gpt-4o", reasoning_effort=None
        )
        assert kwargs == {}


def test_an_explicitly_requested_off_is_narrowed_like_an_inferred_one() -> None:
    """A caller that names ``"none"`` gets the same vendor limit as one that
    says nothing.

    ``default_reasoning_effort_for`` narrowed ``"none"`` to ``"minimal"`` for
    the Gemini families that answer HTTP 400 to it (#734), but it only ran
    when the caller passed nothing. The reader-facing Book blocks name
    ``"none"`` on purpose — so they bypassed the narrowing and shipped the
    exact 400 the table exists to prevent.
    """
    from deeptutor.services.llm.reasoning_params import (
        build_openai_compatible_reasoning_kwargs,
        thinking_off_effort_for,
    )

    def effort(model: str) -> str | None:
        kwargs = build_openai_compatible_reasoning_kwargs(
            spec=None, binding="gemini", model=model, reasoning_effort="none"
        )
        return kwargs.get("reasoning_effort")

    assert effort("gemini-3-pro") == "minimal"
    assert effort("gemini-2.5-pro") == "minimal"
    # A sibling that does accept "none" keeps it, and so does everyone else.
    assert effort("gemini-2.5-flash") == "none"
    assert thinking_off_effort_for("openai", "gpt-4o") == "none"
    assert thinking_off_effort_for(None, None) == "none"


@pytest.mark.parametrize("binding", ["custom", "openai", "dashscope"])
@pytest.mark.parametrize("effort", [None, "high", "none", "minimal"])
@pytest.mark.parametrize("model", ["Qwen/Qwen3-VL-30B-A3B-Instruct", "qwen3_235b_instruct_2507"])
def test_qwen_instruct_omits_unsupported_reasoning_controls(binding, effort, model) -> None:
    assert (
        build_openai_compatible_reasoning_kwargs(
            spec=None, binding=binding, model=model, reasoning_effort=effort
        )
        == {}
    )


@pytest.mark.parametrize("binding", ["custom", "dashscope"])
@pytest.mark.parametrize("effort,enabled", [(None, True), ("high", True), ("none", False)])
def test_qwen_thinking_models_keep_native_controls(binding, effort, enabled) -> None:
    assert build_openai_compatible_reasoning_kwargs(
        spec=None, binding=binding, model="qwen3-235b-a22b", reasoning_effort=effort
    ) == {"extra_body": {"enable_thinking": enabled}}