# SPDX-License-Identifier: Apache-2.0 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project """Qwen3 parser for tool calls and reasoning. Qwen3 XML tool call format:: value The argument body consists of ``VALUE`` tags. The ``_qwen3_arg_converter`` parses these into a JSON object. """ from __future__ import annotations import functools import json from typing import TYPE_CHECKING import regex as re from vllm.parser.engine.events import EventType from vllm.parser.engine.parser_engine import ParserEngine from vllm.parser.engine.parser_engine_config import ( ArgValueExtender, ParserEngineConfig, ParserState, Transition, ) if TYPE_CHECKING: from vllm.entrypoints.openai.chat_completion.protocol import ( ChatCompletionRequest, ) from vllm.entrypoints.openai.responses.protocol import ResponsesRequest from vllm.tokenizers import TokenizerLike from vllm.tool_parsers.abstract_tool_parser import Tool THINK_START = "" THINK_END = "" TOOL_CALL_START = "" TOOL_CALL_END = "" CHATML_TURN_BOUNDARIES = frozenset(("<|im_start|>", "<|im_end|>")) FUNC_PREFIX = "]*)>" r"(.*?)" r"(?:<\s*/\s*parameter\s*>|(?=<\s*parameter\s*=))", re.DOTALL, ) _PARTIAL_PARAM_RE = re.compile(r"<\s*parameter\s*=\s*([^>]+)>(.*)$", re.DOTALL) def _trim_wrapping_newlines(value: str) -> str: """Strip one leading and one trailing newline (the Qwen3 template markup).""" if value.startswith("\n"): value = value[1:] if value.endswith("\n"): value = value[:-1] return value def _qwen3_arg_converter(raw_args: str, partial: bool) -> str: params: dict[str, object] = {} for match in _PARAM_RE.finditer(raw_args): name = match.group(1) value = match.group(2) params[name] = _trim_wrapping_newlines(value) if partial: remaining = _PARAM_RE.sub("", raw_args) m = _PARTIAL_PARAM_RE.search(remaining) if m: name = m.group(1) value = m.group(2) if name: params[name] = _trim_wrapping_newlines(value) return json.dumps(params, ensure_ascii=False) # What ends an open value in ``_PARAM_RE``: a closing tag or the next opener. _PARAM_VALUE_END_RE = re.compile(r"<\s*/\s*parameter\s*>|<\s*parameter\s*=") def _param_value_end_window(text: str) -> str: """Return the suffix of *text* that may still grow into a value end.""" start = text.rfind("<") if start == -1: return "" tail = text[start:] return tail if _PARAM_VALUE_END_RE.fullmatch(tail, partial=True) else "" def _param_value_extender( raw_args: str, trim_newlines: bool ) -> ArgValueExtender | None: """Extend the open trailing ```` value of *raw_args*. The extender streams exactly what the converter would for the same text. With *trim_newlines* it follows ``_trim_wrapping_newlines``: it drops a leading newline of the value and holds back a trailing one. """ match = _PARTIAL_PARAM_RE.search(_PARAM_RE.sub("", raw_args)) if match is None: return None name, value = match.group(1), match.group(2) # A repeated key keeps its first position, so its value is not last. if any(m.group(1) == name for m in _PARAM_RE.finditer(raw_args)): return None window = _param_value_end_window(value) started = bool(value) held = "\n" if trim_newlines and value.endswith("\n") and value != "\n" else "" def extend(delta: str) -> str | None: nonlocal window, started, held text = window + delta if _PARAM_VALUE_END_RE.search(text): return None window = _param_value_end_window(text) if trim_newlines: text = held + delta if not started and text: started = True text = text.removeprefix("\n") held = "\n" if text.endswith("\n") else "" text = text[: len(text) - len(held)] else: text = delta return json.dumps(text, ensure_ascii=False)[1:-1] return extend def _qwen3_arg_value_extender(raw_args: str) -> ArgValueExtender | None: return _param_value_extender(raw_args, trim_newlines=True) @functools.cache def qwen3_config( thinking: bool = True, *, name: str = "qwen3", think_start: str = THINK_START, think_end: str = THINK_END, tool_start: str = TOOL_CALL_START, tool_end: str = TOOL_CALL_END, turn_boundary_tokens: frozenset[str] = frozenset(), ) -> ParserEngineConfig: return ParserEngineConfig( name=name, initial_state=ParserState.REASONING if thinking else ParserState.CONTENT, wait_for_reasoning=thinking, turn_boundary_tokens=turn_boundary_tokens, terminals={ # Reasoning terminals "THINK_START": think_start, "THINK_END": think_end, # Tool call terminals "TOOL_START": tool_start, "TOOL_END": tool_end, "FUNC_PREFIX": FUNC_PREFIX, "FUNC_END": FUNC_END, "PARAM_START": PARAM_START, "PARAM_END": PARAM_END, "CLOSE_ANGLE": ">", }, token_id_terminals={ "THINK_START": think_start, "THINK_END": think_end, "TOOL_START": tool_start, "TOOL_END": tool_end, }, transitions={ # -- Reasoning transitions -- (ParserState.REASONING, "THINK_START"): Transition( ParserState.REASONING, (), ), (ParserState.REASONING, "THINK_END"): Transition( ParserState.CONTENT, (EventType.REASONING_END,), ), # Absorb duplicate — model may emit it after # already transitioning to CONTENT; drop it silently. (ParserState.CONTENT, "THINK_END"): Transition( ParserState.CONTENT, (), ), # Tool call directly from reasoning (implicit end) (ParserState.REASONING, "TOOL_START"): Transition( ParserState.TOOL_PREAMBLE, (EventType.REASONING_END, EventType.TOOL_CALL_START), ), # -- Tool call transitions -- (ParserState.CONTENT, "TOOL_START"): Transition( ParserState.TOOL_PREAMBLE, (EventType.REASONING_END, EventType.TOOL_CALL_START), ), # Fallback: (ParserState.CONTENT, "FUNC_PREFIX"): Transition( ParserState.TOOL_NAME, (EventType.TOOL_CALL_START,), ), (ParserState.TOOL_PREAMBLE, "TOOL_END"): Transition( ParserState.CONTENT, (EventType.TOOL_CALL_END,), ), (ParserState.TOOL_PREAMBLE, "FUNC_PREFIX"): Transition( ParserState.TOOL_NAME, (), ), (ParserState.TOOL_NAME, "CLOSE_ANGLE"): Transition( ParserState.TOOL_ARGS, (), ), # Malformed: while still in TOOL_NAME (no closing >) (ParserState.TOOL_NAME, "FUNC_END"): Transition( ParserState.TOOL_BETWEEN, (EventType.TOOL_CALL_END,), ), # regression issue 58227 # # function name is not closed, go to content (ParserState.TOOL_NAME, "TOOL_END"): Transition( ParserState.CONTENT, (EventType.TOOL_CALL_END,), ), # regression issue 58227 # # unclosed tool call followed by another tool call (ParserState.TOOL_NAME, "TOOL_START"): Transition( ParserState.TOOL_PREAMBLE, (EventType.TOOL_CALL_END, EventType.TOOL_CALL_START), ), # regression issue 58227 # ... (ParserState.TOOL_BETWEEN, "TOOL_START"): Transition( ParserState.TOOL_PREAMBLE, (EventType.TOOL_CALL_START,), ), (ParserState.TOOL_BETWEEN, "FUNC_PREFIX"): Transition( ParserState.TOOL_NAME, (EventType.TOOL_CALL_START,), ), }, arg_converter=_qwen3_arg_converter, arg_value_extender=_qwen3_arg_value_extender, stream_arg_deltas=True, strip_trailing_reasoning_whitespace=False, tool_args_json=False, ) class Qwen3Parser(ParserEngine): """Qwen3 parser: ````/```` reasoning + ```` XML tool calls in a single engine. - ```` as implicit reasoning end (a grammar transition, so it also feeds ``is_reasoning_end`` and the structured-output gate) Subclasses that share the grammar but differ only in the four wrapper token strings (reasoning + tool-call) override the class attributes below; everything else is inherited unchanged. """ CONFIG_NAME = "qwen3" THINK_START = THINK_START THINK_END = THINK_END TOOL_START = TOOL_CALL_START TOOL_END = TOOL_CALL_END TURN_BOUNDARIES: frozenset[str] = CHATML_TURN_BOUNDARIES def __init__( self, tokenizer: TokenizerLike, tools: list[Tool] | None = None, **kwargs, ) -> None: chat_kwargs = kwargs.get("chat_template_kwargs", {}) or {} self.thinking_enabled = chat_kwargs.get("enable_thinking", True) kwargs.setdefault( "parser_engine_config", qwen3_config( thinking=self.thinking_enabled, name=self.CONFIG_NAME, think_start=self.THINK_START, think_end=self.THINK_END, tool_start=self.TOOL_START, tool_end=self.TOOL_END, turn_boundary_tokens=self.TURN_BOUNDARIES, ), ) super().__init__( tokenizer, tools, **kwargs, ) def extract_reasoning( self, model_output: str, request: ChatCompletionRequest | ResponsesRequest, ) -> tuple[str | None, str | None]: if not self.thinking_enabled: return None, model_output return super().extract_reasoning(model_output, request)