feat: added parser name bindings (#2808)

Signed-off-by: Ayush Agarwal <ayushag@nvidia.com>

components/backends/sglang/src/dynamo/sglang/args.py

@@ -14,6 +14,7 @@ from typing import Any, Dict, Optional
 
 from sglang.srt.server_args import ServerArgs
 
+from dynamo._core import get_reasoning_parser_names, get_tool_parser_names
 from dynamo.sglang import __version__
 
 DEFAULT_ENDPOINT = "dyn://dynamo.backend.generate"
@@ -33,13 +34,15 @@ DYNAMO_ARGS: Dict[str, Dict[str, Any]] = {
         "flags": ["--dyn-tool-call-parser"],
         "type": str,
         "default": None,
-        "help": "Tool call parser name for the model. Available options: 'hermes', 'nemotron_deci', 'llama3_json', 'mistral', 'phi4', 'pythonic', 'harmony'.",
+        "choices": get_tool_parser_names(),
+        "help": "Tool call parser name for the model.",
     },
     "reasoning-parser": {
         "flags": ["--dyn-reasoning-parser"],
         "type": str,
         "default": None,
-        "help": "Reasoning parser name for the model. Available options: 'basic', 'deepseek_r1', 'gpt_oss', 'kimi', 'step3', 'qwen3', 'nemotron_deci', 'mistral'.",
+        "choices": get_reasoning_parser_names(),
+        "help": "Reasoning parser name for the model.",
     },
 }
 
@@ -94,6 +97,7 @@ def parse_args(args: list[str]) -> Config:
             type=info["type"],
             default=info["default"] if "default" in info else None,
             help=info["help"],
+            choices=info.get("choices", None),
         )
 
     # SGLang args

components/backends/trtllm/src/dynamo/trtllm/utils/trtllm_utils.py

@@ -6,6 +6,7 @@ from typing import Optional
 
 from tensorrt_llm.llmapi import BuildConfig
 
+from dynamo._core import get_reasoning_parser_names, get_tool_parser_names
 from dynamo.trtllm import __version__
 from dynamo.trtllm.request_handlers.handler_base import (
     DisaggregationMode,
@@ -274,13 +275,15 @@ def cmd_line_args():
         "--dyn-tool-call-parser",
         type=str,
         default=None,
-        help="Tool call parser name for the model. Available options: 'hermes', 'nemotron_deci', 'llama3_json', 'mistral', 'phi4', 'pythonic', 'harmony'.",
+        choices=get_tool_parser_names(),
+        help="Tool call parser name for the model.",
     )
     parser.add_argument(
         "--dyn-reasoning-parser",
         type=str,
         default=None,
-        help="Reasoning parser name for the model. Available options: 'basic', 'deepseek_r1', 'gpt_oss', 'kimi', 'step3', 'qwen3', 'nemotron_deci', 'mistral'.",
+        choices=get_reasoning_parser_names(),
+        help="Reasoning parser name for the model.",
     )
 
     args = parser.parse_args()

components/backends/vllm/src/dynamo/vllm/args.py

@@ -12,6 +12,8 @@ from vllm.distributed.kv_events import KVEventsConfig
 from vllm.engine.arg_utils import AsyncEngineArgs
 from vllm.utils import FlexibleArgumentParser
 
+from dynamo._core import get_reasoning_parser_names, get_tool_parser_names
+
 from . import __version__
 from .ports import (
     DEFAULT_DYNAMO_PORT_MAX,
@@ -111,13 +113,15 @@ def parse_args() -> Config:
         "--dyn-tool-call-parser",
         type=str,
         default=None,
-        help="Tool call parser name for the model. Available options: 'hermes', 'nemotron_deci', 'llama3_json', 'mistral', 'phi4', 'pythonic', 'harmony'.",
+        choices=get_tool_parser_names(),
+        help="Tool call parser name for the model.",
     )
     parser.add_argument(
         "--dyn-reasoning-parser",
         type=str,
         default=None,
-        help="Reasoning parser name for the model. Available options: 'basic', 'deepseek_r1', 'gpt_oss', 'kimi', 'step3', 'qwen3', 'nemotron_deci', 'mistral'.",
+        choices=get_reasoning_parser_names(),
+        help="Reasoning parser name for the model.",
     )
 
     parser = AsyncEngineArgs.add_cli_args(parser)

lib/bindings/python/Cargo.toml

@@ -40,6 +40,7 @@ block-manager = ["dynamo-llm/block-manager", "dep:dlpark", "dep:cudarc"]
 [dependencies]
 dynamo-llm = { path = "../../llm" }
 dynamo-runtime = { path = "../../runtime" }
+dynamo-parsers = { path = "../../parsers" }
 
 anyhow = { version = "1" }
 dynamo-async-openai = { path = "../../async-openai" }

lib/bindings/python/rust/lib.rs

@@ -50,6 +50,7 @@ mod context;
 mod engine;
 mod http;
 mod llm;
+mod parsers;
 
 type JsonServerStreamingIngress =
     Ingress<SingleIn<serde_json::Value>, ManyOut<RsAnnotated<serde_json::Value>>>;
@@ -117,6 +118,7 @@ fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<RouterMode>()?;
 
     engine::add_to_module(m)?;
+    parsers::add_to_module(m)?;
 
     #[cfg(feature = "block-manager")]
     llm::block_manager::add_to_module(m)?;

lib/bindings/python/rust/parsers.rs

+// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use dynamo_parsers::reasoning::get_available_reasoning_parsers;
+use dynamo_parsers::tool_calling::parsers::get_available_tool_parsers;
+use pyo3::prelude::*;
+
+/// Get list of available  parser names
+#[pyfunction]
+pub fn get_tool_parser_names() -> Vec<&'static str> {
+    get_available_tool_parsers()
+}
+
+/// Get list of available reasoning parser names
+#[pyfunction]
+pub fn get_reasoning_parser_names() -> Vec<&'static str> {
+    get_available_reasoning_parsers()
+}
+
+/// Add parsers module functions to the Python module
+pub fn add_to_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(get_tool_parser_names, m)?)?;
+    m.add_function(wrap_pyfunction!(get_reasoning_parser_names, m)?)?;
+    Ok(())
+}

lib/bindings/python/tests/test_parsers.py

+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from dynamo._core import get_reasoning_parser_names, get_tool_parser_names
+
+
+def test_get_tool_parser_names():
+    parsers = get_tool_parser_names()
+    # Just make sure it's not None and has some parsers
+    # No Need to update this test when adding a new parser everytime
+    assert parsers is not None
+    assert len(parsers) > 0
+
+
+def test_get_reasoning_parser_names():
+    parsers = get_reasoning_parser_names()
+    # Just make sure it's not None and has some parsers
+    # No Need to update this test when adding a new parser everytime
+    assert parsers is not None
+    assert len(parsers) > 0

lib/parsers/src/reasoning/mod.rs

 // SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
+use std::collections::HashMap;
+use std::sync::OnceLock;
 
 mod base_parser;
 mod gpt_oss_parser;
@@ -8,6 +10,29 @@ mod gpt_oss_parser;
 pub use base_parser::BasicReasoningParser;
 pub use gpt_oss_parser::GptOssReasoningParser;
 
+static REASONING_PARSER_MAP: OnceLock<HashMap<&'static str, ReasoningParserType>> = OnceLock::new();
+
+/// Initialize the global reasoning parser map
+fn get_reasoning_parser_map() -> &'static HashMap<&'static str, ReasoningParserType> {
+    REASONING_PARSER_MAP.get_or_init(|| {
+        let mut map = HashMap::new();
+        map.insert("deepseek_r1", ReasoningParserType::DeepseekR1);
+        map.insert("basic", ReasoningParserType::Basic);
+        map.insert("gpt_oss", ReasoningParserType::GptOss);
+        map.insert("qwen3", ReasoningParserType::Qwen);
+        map.insert("nemotron_deci", ReasoningParserType::NemotronDeci);
+        map.insert("kimi", ReasoningParserType::Kimi);
+        map.insert("step3", ReasoningParserType::Step3);
+        map.insert("mistral", ReasoningParserType::Mistral);
+        map
+    })
+}
+
+/// Get all available reasoning parser names
+pub fn get_available_reasoning_parsers() -> Vec<&'static str> {
+    get_reasoning_parser_map().keys().copied().collect()
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct ParserResult {
     /// The normal text outside of reasoning blocks.
@@ -144,17 +169,14 @@ impl ReasoningParserType {
     }
 
     pub fn get_reasoning_parser_from_name(name: &str) -> ReasoningParserWrapper {
-        tracing::debug!(parser_name = name, "Selected reasoning parser");
-        match name.to_lowercase().as_str() {
-            "deepseek_r1" => Self::DeepseekR1.get_reasoning_parser(),
-            "basic" => Self::Basic.get_reasoning_parser(),
-            "gpt_oss" => Self::GptOss.get_reasoning_parser(),
-            "qwen3" => Self::Qwen.get_reasoning_parser(),
-            "nemotron_deci" => Self::NemotronDeci.get_reasoning_parser(),
-            "kimi" => Self::Kimi.get_reasoning_parser(),
-            "step3" => Self::Step3.get_reasoning_parser(),
-            "mistral" => Self::Mistral.get_reasoning_parser(),
-            _ => {
+        tracing::debug!("Selected reasoning parser: {}", name);
+
+        let parser_map = get_reasoning_parser_map();
+        let normalized_name = name.to_lowercase();
+
+        match parser_map.get(normalized_name.as_str()) {
+            Some(parser_type) => parser_type.get_reasoning_parser(),
+            None => {
                 tracing::warn!(
                     parser_name = name,
                     "Unknown reasoning parser type, falling back to Basic Reasoning Parser",
@@ -164,3 +186,28 @@ impl ReasoningParserType {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_available_reasoning_parsers() {
+        let parsers = get_available_reasoning_parsers();
+        assert!(!parsers.is_empty());
+        // Update this list when adding a new parser
+        let available_parsers = [
+            "deepseek_r1",
+            "basic",
+            "gpt_oss",
+            "qwen3",
+            "nemotron_deci",
+            "kimi",
+            "step3",
+            "mistral",
+        ];
+        for parser in available_parsers {
+            assert!(parsers.contains(&parser));
+        }
+    }
+}

lib/parsers/src/tool_calling/parsers.rs

@@ -6,6 +6,30 @@ use super::harmony_parser::parse_tool_calls_harmony;
 use super::json_parser::try_tool_call_parse_json;
 use super::pythonic_parser::try_tool_call_parse_pythonic;
 use super::response::ToolCallResponse;
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+static PARSER_MAP: OnceLock<HashMap<&'static str, ToolCallConfig>> = OnceLock::new();
+
+// Always update this parsermap when adding a new parser
+pub fn get_tool_parser_map() -> &'static HashMap<&'static str, ToolCallConfig> {
+    PARSER_MAP.get_or_init(|| {
+        let mut map = HashMap::new();
+        map.insert("hermes", ToolCallConfig::hermes());
+        map.insert("nemotron_deci", ToolCallConfig::nemotron_deci());
+        map.insert("llama3_json", ToolCallConfig::llama3_json());
+        map.insert("mistral", ToolCallConfig::mistral());
+        map.insert("phi4", ToolCallConfig::phi4());
+        map.insert("pythonic", ToolCallConfig::pythonic());
+        map.insert("harmony", ToolCallConfig::harmony());
+        map.insert("default", ToolCallConfig::default());
+        map
+    })
+}
+
+pub fn get_available_tool_parsers() -> Vec<&'static str> {
+    get_tool_parser_map().keys().copied().collect()
+}
 
 pub fn try_tool_call_parse(
     message: &str,
@@ -39,16 +63,8 @@ pub fn detect_and_parse_tool_call(
     message: &str,
     parser_str: Option<&str>,
 ) -> anyhow::Result<(Vec<ToolCallResponse>, Option<String>)> {
-    let mut parser_map: std::collections::HashMap<&str, ToolCallConfig> =
-        std::collections::HashMap::new();
-    parser_map.insert("hermes", ToolCallConfig::hermes());
-    parser_map.insert("nemotron_deci", ToolCallConfig::nemotron_deci());
-    parser_map.insert("llama3_json", ToolCallConfig::llama3_json());
-    parser_map.insert("mistral", ToolCallConfig::mistral());
-    parser_map.insert("phi4", ToolCallConfig::phi4());
-    parser_map.insert("pythonic", ToolCallConfig::pythonic());
-    parser_map.insert("harmony", ToolCallConfig::harmony());
-    parser_map.insert("default", ToolCallConfig::default()); // Add default key
+    // Get the tool parser map
+    let parser_map = get_tool_parser_map();
 
     // Handle None or empty string by defaulting to "default"
     let parser_key = match parser_str {
@@ -61,7 +77,11 @@ pub fn detect_and_parse_tool_call(
             let (results, normal_content) = try_tool_call_parse(message, config)?;
             Ok((results, normal_content))
         }
-        None => anyhow::bail!("Parser for the given config is not implemented"), // Original message
+        None => anyhow::bail!(
+            "Parser '{}' is not implemented. Available parsers: {:?}",
+            parser_key,
+            get_available_tool_parsers()
+        ),
     }
 }
 
@@ -77,6 +97,26 @@ mod tests {
         (call.function.name, args)
     }
 
+    #[test]
+    fn test_get_available_tool_parsers() {
+        let parsers = get_available_tool_parsers();
+        assert!(!parsers.is_empty());
+        // Update this list when adding a new parser
+        let available_parsers = [
+            "hermes",
+            "llama3_json",
+            "harmony",
+            "nemotron_deci",
+            "mistral",
+            "phi4",
+            "default",
+            "pythonic",
+        ];
+        for parser in available_parsers {
+            assert!(parsers.contains(&parser));
+        }
+    }
+
     #[test]
     fn parses_single_parameters_object() {
         let input = r#"{ "name": "hello", "parameters": { "x": 1, "y": 2 } }"#;