feat: support auto-selection and pre-check for function call and reasoning paser.

Author: RobbieLeung

xllm/core/common/global_flags.cpp

@@ -302,13 +302,6 @@ DEFINE_int32(npu_phy_id, -1, "npu phy id");
 
 DEFINE_int32(transfer_listen_port, 26000, "The KVCacheTranfer listen port.");
 
-// --- function call config ---
-
-DEFINE_string(tool_call_parser,
-              "",
-              "Specify the parser for handling tool-call interactions(e.g. "
-              "qwen25, qwen3, kimi_k2, deepseekv3, glm45, glm47).");
-
 // --- speculative config ---
 
 DEFINE_int32(num_speculative_tokens, 0, "Number of speculative tokens.");
@@ -428,7 +421,14 @@ DEFINE_bool(enable_beam_search_kernel,
 DEFINE_string(reasoning_parser,
               "",
               "Specify the reasoning parser for handling reasoning "
-              "interactions(e.g. glm45, glm47, qwen3, deepseek-r1).");
+              "interactions(e.g. auto, glm45, glm47, qwen3, deepseek-r1).");
+
+// --- function call config ---
+
+DEFINE_string(tool_call_parser,
+              "",
+              "Specify the parser for handling tool-call interactions(e.g. "
+              "auto, qwen25, qwen3, kimi_k2, deepseekv3, glm45, glm47).");
 
 // --- qwen3 reranker config ---
 

xllm/core/common/global_flags.h

@@ -133,8 +133,6 @@ DECLARE_bool(enable_customize_mla_kernel);
 
 DECLARE_bool(enable_atb_comm_multiprocess);
 
-DECLARE_string(tool_call_parser);
-
 DECLARE_bool(enable_atb_spec_kernel);
 
 DECLARE_bool(enable_block_copy_kernel);
@@ -217,6 +215,8 @@ DECLARE_bool(enable_qwen3_reranker);
 
 DECLARE_string(reasoning_parser);
 
+DECLARE_string(tool_call_parser);
+
 DECLARE_bool(enable_shm);
 
 DECLARE_bool(use_contiguous_input_buffer);

xllm/core/common/help_formatter.h

@@ -50,7 +50,7 @@ const OptionCategory kCommonOptions = {"COMMON OPTIONS",
 
 const OptionCategory kMoeModelOptions = {
     "MOE MODEL OPTIONS",
-    {"dp_size", "ep_size", "enable_mla", "expert_parallel_degree"}};
+    {"dp_size", "ep_size", "expert_parallel_degree"}};
 
 const OptionCategory kDisaggregatedPrefillDecodeOptions = {
     "DISAGGREGATED PREFILL-DECODE OPTIONS",

xllm/function_call/function_call_parser.cpp

@@ -17,46 +17,74 @@ limitations under the License.
 
 #include <iostream>
 #include <stdexcept>
+#include <unordered_map>
 
 #include "core/util/uuid.h"
 #include "deepseekv3_detector.h"
 #include "glm45_detector.h"
 #include "glm47_detector.h"
 #include "kimik2_detector.h"
 #include "qwen25_detector.h"
+
 namespace xllm {
 namespace function_call {
 
-const std::unordered_map<std::string, std::string>
-    FunctionCallParser::kToolCallParserMap = {
-        {"qwen25", "qwen25"},
-        {"qwen3", "qwen25"},
-        {"kimi_k2", "kimi_k2"},
-        {"deepseekv3", "deepseekv3"},
-        {"glm45", "glm45"},
-        {"glm47", "glm47"},
-        // TODO
-        // {"llama3", "llama3"},
-        // {"mistral", "mistral"},
-        // {"pythonic", "pythonic"},
-        // {"qwen3_coder", "qwen3_coder"},
-        // {"step3", "step3"},
+namespace {
+
+const std::unordered_map<std::string, std::vector<std::string>>
+    AutoToolCallParserMap = {
+        {"qwen25", {"qwen2", "qwen3"}},
+        {"kimi_k2", {"kimi_k2"}},
+        {"deepseekv3", {"deepseek_v3"}},
+        {"glm45", {"glm4_moe"}},
+        {"glm47", {"glm4_moe"}},
 };
 
+}  // namespace
+
+std::string FunctionCallParser::get_parser_auto(const std::string& parser,
+                                                const std::string& model_type) {
+  if (parser.empty()) {
+    return "";
+  }
+  if (parser == "auto") {
+    // find the tool call parser that supports the model type
+    for (const auto& [key, value] : AutoToolCallParserMap) {
+      if (std::find(value.begin(), value.end(), model_type) != value.end()) {
+        LOG(INFO) << "Using tool call parser: " << key
+                  << " for model type: " << model_type;
+        return key;
+      }
+    }
+    LOG(FATAL) << "Unsupported model type for auto tool call parser: "
+               << model_type;
+    return "";
+  } else {
+    // check if the tool call parser is supported
+    if (parser == "qwen2" || parser == "qwen3") {
+      return "qwen25";
+    }
+    if (AutoToolCallParserMap.find(parser) != AutoToolCallParserMap.end()) {
+      return parser;
+    }
+    LOG(FATAL) << "Unsupported tool call parser: " << parser
+               << ". Supported parsers are: " << []() {
+                    std::string supported = "qwen2, qwen3";
+                    for (const auto& [key, value] : AutoToolCallParserMap) {
+                      supported += ", " + key;
+                    }
+                    return supported;
+                  }();
+    return "";
+  }
+}
+
 FunctionCallParser::FunctionCallParser(const std::vector<JsonTool>& tools,
                                        const std::string& tool_call_parser)
     : tools_(tools) {
   detector_ = create_detector(tool_call_parser);
   CHECK(detector_ != nullptr)
-      << "Unsupported tool_call_parser: " << tool_call_parser
-      << ". Supported parsers are: " << [this]() {
-           std::string supported;
-           for (const auto& [key, value] : kToolCallParserMap) {
-             if (!supported.empty()) supported += ", ";
-             supported += key;
-           }
-           return supported;
-         }();
+      << "Unsupported tool_call_parser: " << tool_call_parser;
 }
 
 bool FunctionCallParser::has_tool_call(const std::string& text) const {
@@ -82,38 +110,26 @@ StreamingParseResult FunctionCallParser::parse_streaming_increment(
 
 std::unique_ptr<BaseFormatDetector> FunctionCallParser::create_detector(
     const std::string& tool_call_parser) {
-  auto it = kToolCallParserMap.find(tool_call_parser);
-  if (it == kToolCallParserMap.end()) {
+  if (tool_call_parser.empty()) {
     return nullptr;
   }
 
-  if (it->second == "qwen25") {
+  if (tool_call_parser == "qwen25") {
     return std::make_unique<Qwen25Detector>();
   }
-
-  if (it->second == "kimi_k2") {
+  if (tool_call_parser == "kimi_k2") {
     return std::make_unique<KimiK2Detector>();
   }
-
-  if (it->second == "deepseekv3") {
+  if (tool_call_parser == "deepseekv3") {
     return std::make_unique<DeepSeekV3Detector>();
   }
-
-  if (it->second == "glm45") {
+  if (tool_call_parser == "glm45") {
     return std::make_unique<Glm45Detector>();
   }
-
-  if (it->second == "glm47") {
+  if (tool_call_parser == "glm47") {
     return std::make_unique<Glm47Detector>();
   }
-
-  // if (tool_call_parser == "llama3") {
-  //     return std::make_unique<Llama32Detector>();
-  // }
-  // if (tool_call_parser == "mistral") {
-  //     return std::make_unique<MistralDetector>();
-  // }
-
+  LOG(ERROR) << "Unsupported tool call parser: " << tool_call_parser;
   return nullptr;
 }
 

xllm/function_call/function_call_parser.h

@@ -18,7 +18,6 @@ limitations under the License.
 #include <memory>
 #include <string>
 #include <tuple>
-#include <unordered_map>
 #include <vector>
 
 #include "base_format_detector.h"
@@ -29,8 +28,6 @@ namespace function_call {
 
 class FunctionCallParser {
  public:
-  static const std::unordered_map<std::string, std::string> kToolCallParserMap;
-
   FunctionCallParser(const std::vector<JsonTool>& tools,
                      const std::string& tool_call_parser);
 
@@ -54,6 +51,9 @@ class FunctionCallParser {
 
   BaseFormatDetector* get_detector() const { return detector_.get(); }
 
+  static std::string get_parser_auto(const std::string& parser,
+                                     const std::string& model_type);
+
  private:
   std::unique_ptr<BaseFormatDetector> create_detector(
       const std::string& tool_call_parser);

xllm/function_call/qwen25_detector_test.cpp

@@ -355,7 +355,7 @@ TEST_F(Qwen25DetectorTest, PerformanceWithManyToolCalls) {
 
 // Test basic streaming functionality
 TEST_F(Qwen25StreamingTest, BasicStreamingParsing) {
-  FunctionCallParser parser(tools_, "qwen3");
+  FunctionCallParser parser(tools_, "qwen25");
 
   // Simulate streaming chunks
   std::vector<std::string> chunks = {
@@ -398,7 +398,7 @@ TEST_F(Qwen25StreamingTest, BasicStreamingParsing) {
 
 // Test multiple tool calls streaming
 TEST_F(Qwen25StreamingTest, MultipleToolCallsStreaming) {
-  FunctionCallParser parser(tools_, "qwen3");
+  FunctionCallParser parser(tools_, "qwen25");
 
   // Simulate realistic token-level streaming chunks with multiple tool calls
   std::vector<std::string> chunks = {"Let",
@@ -493,7 +493,7 @@ TEST_F(Qwen25StreamingTest, MultipleToolCallsStreaming) {
 
 // Test partial token handling
 TEST_F(Qwen25StreamingTest, PartialTokenHandling) {
-  FunctionCallParser parser(tools_, "qwen3");
+  FunctionCallParser parser(tools_, "qwen25");
 
   // Simulate realistic partial tokens being streamed - testing edge cases where
   // tokens are split

xllm/parser/detector_registry.cpp

@@ -18,6 +18,8 @@ limitations under the License.
 
 #include <glog/logging.h>
 
+#include <algorithm>
+
 #include "absl/strings/str_join.h"
 
 namespace xllm {
@@ -33,6 +35,16 @@ namespace {
   {name, [](bool stream, bool force) {                                      \
      return std::make_unique<ReasoningDetector>(start, end, force, stream); \
    }}
+
+// Maps reasoning_parser name to supported model_types
+const std::unordered_map<std::string, std::string> AutoReasoningParserMap = {
+    {"deepseek_v3", "deepseek-v3"},
+    {"qwen3", "qwen3"},
+    {"glm4_moe", "glm45"},
+    {"kimi_k2", "kimi"},
+    {"step3", "step3"},
+};
+
 }  // namespace
 
 DetectorRegistry::DetectorRegistry() {
@@ -67,4 +79,21 @@ std::unique_ptr<ReasoningDetector> DetectorRegistry::getDetector(
   return it->second(stream_reasoning, force_reasoning);
 };
 
+std::string DetectorRegistry::getSupportedParsers() const {
+  std::string supported;
+  for (const auto& pair : factories_) {
+    supported += pair.first + ", ";
+  }
+  return supported.substr(0, supported.size() - 2);
+}
+
+std::string DetectorRegistry::getParserNameByModelType(
+    const std::string& model_type) const {
+  auto it = AutoReasoningParserMap.find(model_type);
+  if (it != AutoReasoningParserMap.end()) {
+    return it->second;
+  }
+  LOG(ERROR) << "Unsupported model type for reasoning parser: " << model_type;
+  return "";
+}
 }  // namespace xllm

xllm/parser/detector_registry.h

@@ -37,10 +37,16 @@ class DetectorRegistry {
                                                  bool stream_reasoning,
                                                  bool force_reasoning);
 
-  bool hasDetector(const std::string& model_type) const {
-    return factories_.find(model_type) != factories_.end();
+  bool hasDetector(const std::string& parser_name) const {
+    return factories_.find(parser_name) != factories_.end();
   }
 
+  std::string getSupportedParsers() const;
+
+  // Get the reasoning parser name for auto mode based on model_type
+  // Returns empty string if not found
+  std::string getParserNameByModelType(const std::string& model_type) const;
+
  private:
   DetectorRegistry();
 

xllm/parser/reasoning_parser.cpp

@@ -16,7 +16,10 @@ limitations under the License.
 
 #include "xllm/parser/reasoning_parser.h"
 
+#include <glog/logging.h>
+
 namespace xllm {
+
 ReasoningParser::ReasoningParser(const std::string& model_type,
                                  bool stream_reasoning,
                                  bool force_reasoning) {
@@ -34,4 +37,31 @@ ReasoningResult ReasoningParser::parse_stream_chunk(
       const_cast<std::string&>(chunk_text));
 }
 
+std::string ReasoningParser::get_parser_auto(const std::string& parser,
+                                             const std::string& model_type) {
+  if (parser.empty()) {
+    return "";
+  }
+  auto& registry = DetectorRegistry::getInstance();
+  if (parser == "auto") {
+    // find the reasoning parser that supports the model type
+    std::string parser_name = registry.getParserNameByModelType(model_type);
+    if (parser_name.empty()) {
+      LOG(FATAL) << "Unsupported model type for auto reasoning parser: "
+                 << model_type;
+    }
+    LOG(INFO) << "Using reasoning parser: " << parser_name
+              << " for model type: " << model_type;
+    return parser_name;
+  } else {
+    // check if the reasoning parser is supported
+    if (registry.hasDetector(parser)) {
+      return parser;
+    }
+    LOG(FATAL) << "Unsupported reasoning parser: " << parser
+               << ". Supported parsers are: " << registry.getSupportedParsers();
+    return "";
+  }
+}
+
 }  // namespace xllm

xllm/parser/reasoning_parser.h

@@ -34,6 +34,9 @@ class ReasoningParser {
   // Streaming call: incremental parsing
   ReasoningResult parse_stream_chunk(const std::string& chunk_text);
 
+  static std::string get_parser_auto(const std::string& parser,
+                                     const std::string& model_type);
+
  private:
   std::unique_ptr<ReasoningDetector> detector_;
 };