Struct ParserRegistry 

pub struct ParserRegistry { /* private fields */ }

Registry for model-specific tool parsers with pooling support.

Implementations

impl ParserRegistry

pub fn new() -> Self

Create a new empty registry.

pub fn register_parser<F>(&self, name: &str, creator: F)

where F: Fn() -> Box<dyn ToolParser> + Send + Sync + 'static,

Register a parser without structural tag support.

pub fn register_parser_with_structural_tag<F>( &self, name: &str, creator: F, build_structural_tag: fn(&[Tool], bool) -> Value, )

where F: Fn() -> Box<dyn ToolParser> + Send + Sync + 'static,

Register a parser with a structural tag builder.

The build_structural_tag function takes (&[Tool], at_least_one) and returns the full xgrammar structural tag JSON for this parser’s native tool-call format.

pub fn register_reasoning_prefix( &self, name: &str, reasoning_prefix: fn(GrammarStart) -> Option<Value>, )

Register the reasoning block for a parser that already has a structural tag builder.

When Self::generate_tool_constraint is called with reasoning set, the parser’s tag becomes sequence[prefix, tag.format] with the prefix for GrammarStart::Unknown: free text, then the forced call. Unlike xgrammar’s built-in tags with reasoning=True, that prefix is not closed by the thought’s end token: an engine that runs a reasoning parser applies the grammar only after the model’s own </think> and would hold the model to a second one. Once the worker that runs the grammar is known, Self::structural_tag_for_grammar_start re-shapes the prefix for where that engine starts the grammar. Parsers without a prefix keep their unwrapped tag whatever reasoning says.

pub fn has_reasoning_prefix(&self, configured: Option<&str>) -> bool

Whether the configured parser wraps its structural tag in a reasoning block when asked (see Self::register_reasoning_prefix). False when no parser is configured, like Self::has_structural_tag_for_parser.

pub fn structural_tag_for_grammar_start( &self, configured_parser: Option<&str>, tag: &str, start: GrammarStart, ) -> Result<Option<String>, String>

A forced call’s structural tag, as Self::generate_tool_constraint built it on a thinking prompt, re-shaped for where the engine that will run it starts the grammar: for GrammarStart::AfterReasoning the prefix is dropped (the grammar starts at the engine’s gate, so the first constrained token opens a call); for GrammarStart::FirstToken the prefix becomes the parser’s thought block, closed by </think>, so the call follows the thought. Ok(None) leaves the tag as it is: the start is unknown, the parser has no prefix, or the tag does not carry one (a prompt outside the thinking block).

pub fn map_model(&self, model: impl Into<String>, parser: impl Into<String>)

Map a model name/pattern to a parser

pub fn get_pooled_parser(&self, name: &str) -> Option<PooledParser>

Get a pooled parser by exact name. Returns a shared parser instance from the pool, creating one if needed.

pub fn has_parser(&self, name: &str) -> bool

Check if a parser with the given name is registered.

pub fn create_parser(&self, name: &str) -> Option<Box<dyn ToolParser>>

Create a fresh (non-pooled) parser instance by exact name. Returns a new parser instance for each call - useful for streaming where state isolation is needed.

pub fn has_structural_tag(&self, name: &str) -> bool

Check if the parser supports structural tag constraints.

pub fn has_structural_tag_for_parser(&self, configured: Option<&str>) -> bool

Check if the configured parser supports structural tags. Returns false if no parser is configured (structural tags require explicit opt-in via --tool-call-parser).

pub fn uses_native_tool_format(&self, configured: Option<&str>) -> bool

Whether required/named responses retain model-native framing rather than the generic JSON schema fallback. Gemma4 follows vLLM’s native choice handling without claiming structural-tag grammar support.

pub fn generate_tool_constraint( &self, configured_parser: Option<&str>, tools: &[Tool], tool_choice: &ToolChoice, reasoning: bool, ) -> Result<Option<ToolConstraint>, String>

Generate tool call constraint.

If configured_parser supports structural tags → StructuralTag(json). Gemma4 emits its native format without a decoding constraint. Otherwise → JsonSchema(schema) for required/function tool_choice. Returns Ok(None) for auto/none tool_choice.

reasoning says the rendered prompt ends inside the model’s thinking block (the gateway’s chat_reasoning_starts_in_prefill). A parser that registered a reasoning prefix then gets its tag wrapped so the forced call follows the reasoning instead of preempting it; every other constraint is unchanged and applies from the first generated token.

pub fn resolve_model_to_parser(&self, model: &str) -> Option<String>

Resolve model name to parser name via model mappings. Returns None if no mapping matches (caller decides fallback).

pub fn has_parser_for_model(&self, model: &str) -> bool

Check if a parser can be created for a specific model without actually creating it.

pub fn create_for_model(&self, model: &str) -> Option<Box<dyn ToolParser>>

Create a fresh (non-pooled) parser instance for a specific model.

pub fn get_pooled_for_model(&self, model: &str) -> Option<PooledParser>

Get parser for a specific model

pub fn clear_pool(&self)

Clear the parser pool, forcing new instances to be created.

pub fn set_default_parser(&self, name: impl Into<String>)

Set the default parser

Trait Implementations

impl Clone for ParserRegistry

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for ParserRegistry

fn default() -> Self

Returns the “default value” for a type.