feat: Support deployment-level thinking defaults for chat templates

components/src/dynamo/common/backend/tests/test_backend_bindings.py

@@ -114,6 +114,7 @@ def test_worker_config_accepts_parser_runtime_settings():
         namespace="dynamo",
         tool_call_parser="kimi_k2",
         reasoning_parser="kimi_k25",
+        default_thinking_mode="disabled",
         exclude_tools_when_tool_choice_none=False,
         enable_local_indexer=False,
     )
@@ -146,6 +147,7 @@ def test_python_worker_config_from_runtime_config_copies_parser_settings():
     runtime_cfg.custom_jinja_template = None
     runtime_cfg.dyn_tool_call_parser = "kimi_k2"
     runtime_cfg.dyn_reasoning_parser = "kimi_k25"
+    runtime_cfg.dyn_default_thinking_mode = "disabled"
     runtime_cfg.exclude_tools_when_tool_choice_none = False
     runtime_cfg.enable_local_indexer = False
     runtime_cfg.dyn_enable_structural_tag = True
@@ -160,6 +162,7 @@ def test_python_worker_config_from_runtime_config_copies_parser_settings():
 
     assert config.tool_call_parser == "kimi_k2"
     assert config.reasoning_parser == "kimi_k25"
+    assert config.default_thinking_mode == "disabled"
     assert config.exclude_tools_when_tool_choice_none is False
     assert config.enable_local_indexer is False
     assert config.structural_tag_mode == "on"
@@ -184,6 +187,7 @@ class _BareRuntime:
     assert cfg.endpoint_types == "chat,completions"
     assert cfg.use_kv_events is False
     assert cfg.custom_jinja_template is None
+    assert cfg.default_thinking_mode is None
     assert cfg.structural_tag_mode == "off"
     assert cfg.structural_tag_scope == "auto"
     assert cfg.structural_tag_schema == "auto"

components/src/dynamo/common/backend/worker.py

@@ -117,6 +117,7 @@ class WorkerConfig:
     custom_jinja_template: Optional[str] = None
     tool_call_parser: Optional[str] = None
     reasoning_parser: Optional[str] = None
+    default_thinking_mode: Optional[str] = None
     exclude_tools_when_tool_choice_none: bool = True
     enable_local_indexer: bool = True
     # Operator-level kill switch for KV-aware-routing publishers. When False,
@@ -175,6 +176,9 @@ def from_runtime_config(
             ),
             "tool_call_parser": getattr(runtime_cfg, "dyn_tool_call_parser", None),
             "reasoning_parser": getattr(runtime_cfg, "dyn_reasoning_parser", None),
+            "default_thinking_mode": getattr(
+                runtime_cfg, "dyn_default_thinking_mode", None
+            ),
             "exclude_tools_when_tool_choice_none": getattr(
                 runtime_cfg, "exclude_tools_when_tool_choice_none", True
             ),
@@ -260,6 +264,7 @@ async def run(self) -> None:
             custom_jinja_template=self.config.custom_jinja_template,
             tool_call_parser=self.config.tool_call_parser,
             reasoning_parser=self.config.reasoning_parser,
+            default_thinking_mode=self.config.default_thinking_mode,
             exclude_tools_when_tool_choice_none=(
                 self.config.exclude_tools_when_tool_choice_none
             ),

components/src/dynamo/common/configuration/groups/runtime_args.py

@@ -28,6 +28,7 @@ class DynamoRuntimeConfig(ConfigBase):
 
     dyn_tool_call_parser: Optional[str] = None
     dyn_reasoning_parser: Optional[str] = None
+    dyn_default_thinking_mode: Optional[str] = None
     exclude_tools_when_tool_choice_none: bool = True
     dyn_enable_structural_tag: bool = False
     dyn_structural_tag_scope: str = "auto"
@@ -160,6 +161,15 @@ def add_arguments(self, parser: argparse.ArgumentParser) -> None:
             help="Reasoning parser name for the model. If not specified, no reasoning parsing is performed.",
             choices=get_reasoning_parser_names(),
         )
+        add_argument(
+            g,
+            flag_name="--dyn-default-thinking-mode",
+            env_var="DYN_DEFAULT_THINKING_MODE",
+            default=None,
+            choices=["enabled", "disabled"],
+            help="Deployment-level default thinking mode for chat templates. "
+            "Client request thinking/chat_template_args values override this default.",
+        )
         # NOTE: This flag also exists in FrontendArgGroup (frontend_args.py).
         # Both definitions are needed: this one controls the Rust-native chat
         # template path (oai.rs), while the frontend copy controls the Python

components/src/dynamo/frontend/prepost.py

@@ -22,6 +22,8 @@
 from vllm.tool_parsers import ToolParser
 from vllm.utils.async_utils import AsyncMicrobatchTokenizer
 
+from .thinking import apply_default_thinking_mode_to_template_kwargs
+
 
 class _Renderer(Protocol):
     """Structural type for vLLM's chat-template renderer."""
@@ -90,6 +92,7 @@ def _prepare_request(
     tool_parser_class: type[ToolParser] | None,
     exclude_tools_when_tool_choice_none: bool = True,
     enable_auto_tool_choice: bool = False,
+    default_thinking_mode: str | None = None,
 ) -> tuple[ChatCompletionRequest, ToolParser | None, dict[str, Any], Any, ChatParams]:
     """Validate request and build arguments for template rendering.
 
@@ -134,6 +137,11 @@ def _prepare_request(
         else None
     )
     chat_template_kwargs = dict(request_for_sampling.chat_template_kwargs or {})
+    chat_template_kwargs = apply_default_thinking_mode_to_template_kwargs(
+        chat_template_kwargs,
+        default_thinking_mode,
+        request_has_root_thinking=(isinstance(request, dict) and "thinking" in request),
+    )
     chat_template_kwargs["reasoning_effort"] = request_for_sampling.reasoning_effort
 
     # Mistral warns that tokenize=False is unsafe for chat templates.
@@ -178,6 +186,7 @@ async def preprocess_chat_request(
     tool_parser_class: type[ToolParser] | None,
     exclude_tools_when_tool_choice_none: bool = True,
     enable_auto_tool_choice: bool = False,
+    default_thinking_mode: str | None = None,
 ) -> PreprocessResult:
     (
         request_for_sampling,
@@ -191,6 +200,7 @@ async def preprocess_chat_request(
         tool_parser_class=tool_parser_class,
         exclude_tools_when_tool_choice_none=exclude_tools_when_tool_choice_none,
         enable_auto_tool_choice=enable_auto_tool_choice,
+        default_thinking_mode=default_thinking_mode,
     )
 
     _, engine_prompt = await renderer.render_messages_async(messages, chat_params)

components/src/dynamo/frontend/sglang_prepost.py

@@ -28,6 +28,7 @@
 )
 from sglang.srt.parser.reasoning_parser import ReasoningParser
 
+from .thinking import apply_default_thinking_mode_to_template_kwargs
 from .utils import random_call_id
 
 logger = logging.getLogger(__name__)
@@ -364,6 +365,7 @@ def _flatten_message_content(content: Any) -> Any:
 
 def _normalize_openai_thinking_template_kwargs(
     request: dict[str, Any],
+    default_thinking_mode: str | None = None,
 ) -> dict[str, Any]:
     request = copy.copy(request)
     chat_template_kwargs = dict(
@@ -388,6 +390,12 @@ def setdefault_reasoning(enabled: bool) -> None:
     if request.get("reasoning_effort") == "none":
         setdefault_reasoning(False)
 
+    chat_template_kwargs = apply_default_thinking_mode_to_template_kwargs(
+        chat_template_kwargs,
+        default_thinking_mode,
+        request_has_root_thinking="thinking" in request,
+    )
+
     if chat_template_kwargs:
         request["chat_template_kwargs"] = chat_template_kwargs
     return request
@@ -613,6 +621,7 @@ def preprocess_chat_request(
     reasoning_parser_name: str | None,
     exclude_tools_when_tool_choice_none: bool = True,
     template_force_reasoning: bool = False,
+    default_thinking_mode: str | None = None,
 ) -> SglangPreprocessResult:
     """Preprocess a chat request using SGLang tokenizer and parser APIs.
 
@@ -623,7 +632,7 @@ def preprocess_chat_request(
 
     Synchronous -- suitable for both main-process and worker-process execution.
     """
-    request = _normalize_openai_thinking_template_kwargs(request)
+    request = _normalize_openai_thinking_template_kwargs(request, default_thinking_mode)
     messages = _materialize_messages(request.get("messages", []))
 
     # Per-request client escape hatch: skip reasoning parsing entirely when

components/src/dynamo/frontend/sglang_processor.py

@@ -33,6 +33,7 @@
     detect_force_reasoning_from_template,
     preprocess_chat_request,
 )
+from .thinking import runtime_default_thinking_mode
 from .utils import (
     PreprocessError,
     extract_mm_urls,
@@ -118,6 +119,7 @@ def _map_finish_reason(raw: str | None) -> str | None:
 _w_reasoning_parser_name: str | None = None
 _w_exclude_tools_when_tool_choice_none: bool = True
 _w_template_force_reasoning: bool = False
+_w_default_thinking_mode: str | None = None
 
 
 @dataclass
@@ -142,15 +144,18 @@ def _init_worker(
     exclude_tools_when_tool_choice_none: bool = True,
     trust_remote_code: bool = False,
     template_force_reasoning: bool = False,
+    default_thinking_mode: str | None = None,
 ) -> None:
     """Initialize a worker process with its own tokenizer."""
     global _w_tokenizer, _w_tool_call_parser_name, _w_reasoning_parser_name
     global _w_exclude_tools_when_tool_choice_none, _w_template_force_reasoning
+    global _w_default_thinking_mode
     _w_tokenizer = _load_tokenizer(model_path, trust_remote_code)
     _w_tool_call_parser_name = tool_call_parser_name
     _w_reasoning_parser_name = reasoning_parser_name
     _w_exclude_tools_when_tool_choice_none = exclude_tools_when_tool_choice_none
     _w_template_force_reasoning = template_force_reasoning
+    _w_default_thinking_mode = default_thinking_mode
 
 
 def _preprocess_worker(
@@ -166,6 +171,7 @@ def _preprocess_worker(
         reasoning_parser_name=_w_reasoning_parser_name,
         exclude_tools_when_tool_choice_none=_w_exclude_tools_when_tool_choice_none,
         template_force_reasoning=_w_template_force_reasoning,
+        default_thinking_mode=_w_default_thinking_mode,
     )
 
     n = request.get("n", 1)
@@ -293,6 +299,7 @@ def __init__(
         preprocess_pool: ProcessPoolExecutor | None = None,
         preprocess_workers: int = 0,
         stream_interval: int = 1,
+        default_thinking_mode: str | None = None,
     ):
         self.tokenizer = tokenizer
         # Detect force_reasoning once from the chat template, matching
@@ -316,6 +323,7 @@ def __init__(
         self.eos_token_id = eos_token_id
         self.debug_perf = debug_perf
         self.stream_interval = stream_interval
+        self.default_thinking_mode = default_thinking_mode
         self.preprocess_pool = preprocess_pool
         if preprocess_pool is not None:
             self._worker_semaphore: asyncio.Semaphore | None = asyncio.Semaphore(
@@ -372,6 +380,7 @@ async def _generator_inner(
                 reasoning_parser_name=self.reasoning_parser_name,
                 exclude_tools_when_tool_choice_none=self.exclude_tools_when_tool_choice_none,
                 template_force_reasoning=self.template_force_reasoning,
+                default_thinking_mode=self.default_thinking_mode,
             )
 
             if self.debug_perf:
@@ -694,11 +703,14 @@ async def chat_engine_factory(
             self.reasoning_parser_name
             or _runtime_config_parser_name(mdc, "reasoning_parser")
         )
+        default_thinking_mode = runtime_default_thinking_mode(mdc.runtime_config())
 
         if tool_call_parser_name:
             logger.info("SGLang tool call parser: %s", tool_call_parser_name)
         if reasoning_parser_name:
             logger.info("SGLang reasoning parser: %s", reasoning_parser_name)
+        if default_thinking_mode:
+            logger.info("SGLang default thinking mode: %s", default_thinking_mode)
 
         preprocess_pool = None
         preprocess_workers = self.config.preprocess_workers
@@ -718,6 +730,7 @@ async def chat_engine_factory(
                     self.config.exclude_tools_when_tool_choice_none,
                     self.trust_remote_code,
                     template_force_reasoning,
+                    default_thinking_mode,
                 ),
             )
             futures = [
@@ -753,6 +766,7 @@ async def chat_engine_factory(
             preprocess_pool=preprocess_pool,
             preprocess_workers=preprocess_workers,
             stream_interval=self.stream_interval,
+            default_thinking_mode=default_thinking_mode,
         )
         gen.exclude_tools_when_tool_choice_none = (
             self.config.exclude_tools_when_tool_choice_none

components/src/dynamo/frontend/tests/test_sglang_processor_unit.py

@@ -1645,6 +1645,63 @@ def apply_chat_template(self, messages, **kwargs):
         assert result.request["chat_template_kwargs"]["enable_thinking"] is True
         assert result.force_reasoning is True
 
+    def test_default_thinking_mode_disabled_reaches_generic_chat_template(self):
+        captured = {}
+
+        class CapturingTokenizer:
+            chat_template = "template"
+
+            def apply_chat_template(self, messages, **kwargs):
+                captured["kwargs"] = kwargs
+                return [1, 2, 3]
+
+        request = {
+            "model": "generic-model",
+            "messages": [{"role": "user", "content": "Hello"}],
+        }
+
+        result = preprocess_chat_request(
+            request,
+            tokenizer=CapturingTokenizer(),
+            tool_call_parser_name=None,
+            reasoning_parser_name=None,
+            default_thinking_mode="disabled",
+        )
+
+        assert result.prompt_token_ids == [1, 2, 3]
+        assert captured["kwargs"]["thinking"] is False
+        assert captured["kwargs"]["enable_thinking"] is False
+        assert captured["kwargs"]["thinking_mode"] == "disabled"
+        assert result.request["chat_template_kwargs"]["thinking_mode"] == "disabled"
+        assert "chat_template_kwargs" not in request
+
+    def test_default_thinking_mode_does_not_override_request_kwargs(self):
+        captured = {}
+
+        class CapturingTokenizer:
+            chat_template = "template"
+
+            def apply_chat_template(self, messages, **kwargs):
+                captured["kwargs"] = kwargs
+                return [1, 2, 3]
+
+        result = preprocess_chat_request(
+            {
+                "model": "generic-model",
+                "messages": [{"role": "user", "content": "Hello"}],
+                "chat_template_kwargs": {"enable_thinking": True},
+            },
+            tokenizer=CapturingTokenizer(),
+            tool_call_parser_name=None,
+            reasoning_parser_name=None,
+            default_thinking_mode="disabled",
+        )
+
+        assert result.prompt_token_ids == [1, 2, 3]
+        assert captured["kwargs"]["enable_thinking"] is True
+        assert "thinking" not in captured["kwargs"]
+        assert "thinking_mode" not in captured["kwargs"]
+
     def test_deepseek_v4_named_tool_choice_filters_encoder_tools(self, monkeypatch):
         captured = {}
         fake_module = types.ModuleType("sglang.srt.entrypoints.openai.encoding_dsv4")

components/src/dynamo/frontend/tests/test_vllm_processor_unit.py

@@ -502,6 +502,39 @@ def test_reasoning_effort_forwarded_to_template_kwargs(self, tokenizer):
         )
         assert chat_params.chat_template_kwargs.get("reasoning_effort") == "low"
 
+    def test_default_thinking_mode_disabled_reaches_template_kwargs(self, tokenizer):
+        _, _, chat_template_kwargs, _, chat_params = _prepare_request(
+            {
+                "model": MODEL,
+                "messages": self._messages(),
+            },
+            tokenizer=tokenizer,
+            tool_parser_class=None,
+            default_thinking_mode="disabled",
+        )
+
+        for kwargs in (chat_template_kwargs, chat_params.chat_template_kwargs):
+            assert kwargs["thinking"] is False
+            assert kwargs["enable_thinking"] is False
+            assert kwargs["thinking_mode"] == "disabled"
+
+    def test_default_thinking_mode_does_not_override_request_kwargs(self, tokenizer):
+        _, _, chat_template_kwargs, _, chat_params = _prepare_request(
+            {
+                "model": MODEL,
+                "messages": self._messages(),
+                "chat_template_kwargs": {"enable_thinking": True},
+            },
+            tokenizer=tokenizer,
+            tool_parser_class=None,
+            default_thinking_mode="disabled",
+        )
+
+        for kwargs in (chat_template_kwargs, chat_params.chat_template_kwargs):
+            assert kwargs["enable_thinking"] is True
+            assert "thinking" not in kwargs
+            assert "thinking_mode" not in kwargs
+
 
 @pytest.mark.parametrize(
     ("runtime_config", "expected"),