Reasoning Parsing (Dynamo)

Some models emit reasoning or thinking content separately from their final response. Dynamo can split that output into reasoning_content and normal assistant content by configuring --dyn-reasoning-parser on the backend worker.

This page covers parser names for the default Dynamo-native path. If Dynamo does not list a parser for your model, see Parser Engine Fallback. For how --dyn-reasoning-parser combines with --dyn-chat-processor and --dyn-tool-call-parser (and which combinations are invalid), see Parser Configuration.

Prerequisites

To enable reasoning parsing, launch the backend worker with:

• --dyn-reasoning-parser: select the reasoning parser from the supported list below

For vLLM structured output, or SGLang required/named tool choice, also configure the engine’s native --reasoning-parser. It controls when the grammar starts; Dynamo’s parser populates reasoning_content. Parser names can differ between registries.

$
# <backend> can be sglang, trtllm, vllm, etc. based on your installation
$
python -m dynamo.<backend> --help

Supported Reasoning Parsers

The table below lists the currently supported reasoning parsers in Dynamo’s registry. The Upstream name column shows where the vLLM or SGLang parser name differs from Dynamo’s. This is relevant for engine fallback and when configuring the native structured-output reasoning gate. A blank upstream column means the same name works everywhere. Dynamo-only means no upstream parser exists for this format.

Parsers marked force-reasoning emit reasoning content from token one without requiring an explicit opening tag (<think>, etc.). All others require the opening tag to be present in the model output.

Model-Specific Limitations

Common Parser Pairings

Some models need both parsers configured together. Common pairings include:

• openai/gpt-oss-*: --dyn-tool-call-parser harmony --dyn-reasoning-parser gpt_oss
• deepseek-ai/DeepSeek-V4-*: --dyn-tool-call-parser deepseek_v4 --dyn-reasoning-parser deepseek_v4
• zai-org/GLM-4.7: --dyn-tool-call-parser glm47 --dyn-reasoning-parser glm45
• moonshotai/Kimi-K2.5* / Kimi K2.6 format-compatible outputs: --dyn-tool-call-parser kimi_k2 --dyn-reasoning-parser kimi_k25
• google/gemma-4-* thinking models: --dyn-tool-call-parser gemma4 --dyn-reasoning-parser gemma4 --custom-jinja-template examples/chat_templates/gemma4_tool.jinja
• Qwen/Qwen3.5*: --dyn-tool-call-parser qwen3_coder --dyn-reasoning-parser qwen3
• MiniMax M2 style outputs: --dyn-tool-call-parser minimax_m2 --dyn-reasoning-parser minimax_m2
• MiniMax M3 style outputs: --dyn-tool-call-parser minimax_m3 --dyn-reasoning-parser minimax_m3

Tool Calling Interplay

Reasoning parsing happens before tool call parsing. If a model emits both reasoning content and tool calls, configure both parsers so Dynamo can first separate reasoning text and then parse tool calls from the remaining assistant output.

Examples

Launch Dynamo Frontend and Backend

$
# launch backend worker (or dynamo.vllm)
$
python -m dynamo.sglang --model Qwen/Qwen3.5-4B --dyn-tool-call-parser qwen3_coder --reasoning-parser qwen3 --dyn-reasoning-parser qwen3
$
$
# launch frontend worker
$
python -m dynamo.frontend

Reasoning Request Example

$
curl -s http://localhost:8000/v1/chat/completions \
>
  -H 'Content-Type: application/json' \
>
  -d '{
>
    "model": "Qwen/Qwen3.5-4B",
>
    "messages": [{"role": "user", "content": "If a train leaves at 3pm going 60 mph and another leaves at 4pm going 80 mph, when does the second catch up?"}]
>
  }'

Dynamo splits the model output so the chain-of-thought lands in reasoning_content and the user-facing answer stays in content:

1
{
2
  "choices": [
3
    {
4
      "index": 0,
5
      "message": {
6
        "role": "assistant",
7
        "reasoning_content": "The first train has a 1-hour head start at 60 mph, so it is 60 miles ahead at 4pm. The second train closes the gap at 80 - 60 = 20 mph. 60 / 20 = 3 hours after 4pm.",
8
        "content": "The second train catches up at 7pm."
9
      },
10
      "finish_reason": "stop"
11
    }
12
  ]
13
}