vllm-project/vllm · error · ReasoningError

`{name}` only provides a unified parser; the same reasoning

Error message

`{name}` only provides a unified parser; the same reasoning parser and tool parser should be specified together

What it means

ReasoningError::DummyUnifiedParser is returned when code tries to instantiate a standalone (split) reasoning parser from a parser family that only ships a unified parser. Unified parsers (e.g. granite-style) parse reasoning and tool calls together, so a reasoning-only split instance is meaningless and is rejected at construction.

Source

Thrown at rust/src/parser/src/reasoning/mod.rs:133

    fn preserve_special_tokens(&self) -> bool {
        false
    }

    /// Feed one decoded text delta into the parser.
    fn push(&mut self, delta: &str) -> Result<ReasoningDelta>;

    /// Flush any buffered partial delimiter state at end of stream.
    fn finish(&mut self) -> Result<ReasoningDelta> {
        Ok(ReasoningDelta::default())
    }
}

/// Errors produced while creating or running reasoning parsers.
#[derive(Debug, Error)]
pub enum ReasoningError {
    #[error("tokenizer is missing reasoning delimiter token `{token}`")]
    MissingToken { token: String },
    #[error(
        "`{name}` only provides a unified parser; the same reasoning parser and tool parser should be specified together"
    )]
    DummyUnifiedParser { name: String },
}

#[cfg(test)]
mod tests;

View on GitHub (pinned to c794754062)

Solutions

1. Specify the same family for both parsers (reasoning AND tool) so the unified parser is constructed
2. If you only need reasoning output, choose a family that ships a split reasoning parser
3. When enumerating parsers programmatically, skip families that only expose the unified variant

Example fix

# before
--reasoning-parser granite

# after
--reasoning-parser granite --tool-parser granite

// Unified-only families must be enabled for both parser roles
let unified_only = matches!(name.as_str(), "granite");
if unified_only && tool_parser_name != name {
    return Err(anyhow::anyhow!("{name} requires --tool-parser {name} too"));
}

fn is_dummy_unified_reasoning(e: &ReasoningError) -> bool {
    matches!(e, ReasoningError::DummyUnifiedParser { .. })
}

match build_reasoning_parser(name, tokenizer) {
    Err(ReasoningError::DummyUnifiedParser { name }) => {
        eprintln!("{name} is unified-only; set both --reasoning-parser and --tool-parser to {name}");
        std::process::exit(2);
    }
    r => r,
}

When it happens

Trigger: Calling the reasoning-parser factory with a parser name whose family provides only the unified implementation — i.e. enabling reasoning parsing without the matching tool parser for the same family.

Common situations: Configuring --reasoning-parser granite but not --tool-parser granite; library code that enumerates all reasoning parsers and tries to build each one; migrating from split to unified parser API.

Related errors

• `{name}` only provides a unified parser; the same reasoning
• tokenizer is missing reasoning delimiter token `{token}`
• tokenizer is missing unified parser token `{token}`
• {kind} parser `{name}` is not registered{}
• gpt_oss uses native Harmony output parsing; generic {kind} p

AI-assisted analysis of vllm-project/vllm@c794754062 (2026-08-14). Data as JSON: /api/errors/2395f9f7ab903d12. Report an issue: GitHub.