fix(sglang): force reasoning when the template prefills the think tag

[pos-ei-don]

Description

Qwen3-style chat templates append the opening <think> tag to the prompt when thinking
is enabled. The model therefore never generates it and emits only the reasoning text plus the
closing </think>.

sglang's ReasoningParser keys off the opening tag:

in_reasoning = self._in_reasoning or self.think_start_token in text
if not in_reasoning:
    return StreamingParseResult(normal_text=text)

With such a template the entire completion — reasoning, the raw </think>, and the answer —
comes back as content, and reasoning_content stays empty no matter how reasoning_parser
is configured:

ReasoningParser("qwen3", stream_reasoning=False)                        reasoning    0 chars
ReasoningParser("qwen3", stream_reasoning=False, force_reasoning=True)  reasoning  746 chars
                                                                        content     28 chars

sglang's own OpenAI server solves this with

force_reasoning = (self.template_manager.force_reasoning
                   or self._get_reasoning_from_request(request))

This backend has no template manager, so the same signal is derived from the rendered prompt:
if it ends with the detector's think_start_token, the tag was prefilled and the parser is
constructed with force_reasoning=True.

Notes for Reviewers

Why this is conditional rather than always on. Forcing unconditionally breaks the
thinking-off case — a completion with no tags at all is then filed entirely as reasoning and
the answer disappears:

19 chars of output, no </think>
  without force : reasoning   0    content  19   "2,3,5,7,11,13,17,19"
  with    force : reasoning  19    content   0   ""      <- answer gone

force_reasoning is only passed when it is meant to be True, so detector defaults
(DeepSeek-R1 already defaults to True) are untouched.

Structured decoding is the exception, and it matters. A grammar applies from the first
token, so the model cannot emit the closing tag even though the template opened the block.
The whole completion is schema output and belongs in content; forcing there files it as
reasoning and returns an empty answer. Measured against a JSON-schema code audit:
10107 characters of "reasoning", zero content. sglang's own server keeps the two apart
for the same reason — its grammar backend owns the reasoning prefix when a reasoning parser
is configured. Hence the grammar_constrained guard, with a regression test for it.

The construction is factored into _new_reasoning_parser() so the streaming and
non-streaming paths, which previously built the parser separately, cannot drift apart.

Tested against Qwen3-style models on an sglang backend; backend/python/sglang/test.py covers
the prefilled-tag case, the thinking-off case and the grammar case.

Signed commits

• Yes, I signed my commits.
• Documentation updated (docs/content/) for user-facing changes, or not applicable

[localai-org-maint-bot]

Good to merge from my review. The prefilled-think-tag detection is scoped correctly, grammar-constrained output is preserved as content, and both parser paths share the same construction logic. Regression coverage, Python syntax checks, and diff checks look clean. @mudler