Skip to content

GitLab

Unverified Commit 4463e90d authored by Chang Su's avatar Chang Su Committed by GitHub
Browse files

[router][grpc] Remove gpt_oss parsers and remove _parser suffix in tool parser files (#12091)

parent 229f236d
Hide whitespace changes
Inline Side-by-side
Showing with 24 additions and 564 deletions
sgl-router/src/tool_parser/factory.rs
View file @ 4463e90d
......@@ -9,8 +9,8 @@ use tokio::sync::Mutex;
use crate::tool_parser::{
parsers::{
DeepSeekParser, Glm4MoeParser, GptOssHarmonyParser, GptOssParser, JsonParser, KimiK2Parser,
LlamaParser, MistralParser, PassthroughParser, PythonicParser, QwenParser, Step3Parser,
DeepSeekParser, Glm4MoeParser, JsonParser, KimiK2Parser, LlamaParser, MistralParser,
PassthroughParser, PythonicParser, QwenParser, Step3Parser,
},
traits::ToolParser,
};
......@@ -243,17 +243,6 @@ impl ParserFactory {
registry.register_parser("step3", || Box::new(Step3Parser::new()));
registry.register_parser("kimik2", || Box::new(KimiK2Parser::new()));
// Register GPT-OSS parsers
registry.register_parser("gpt_oss_legacy", || Box::new(GptOssParser::new()));
registry.register_parser("gpt_oss_harmony", || Box::new(GptOssHarmonyParser::new()));
// Choose which GPT-OSS variant to use as default
if use_harmony_gpt_oss() {
registry.register_parser("gpt_oss", || Box::new(GptOssHarmonyParser::new()));
} else {
registry.register_parser("gpt_oss", || Box::new(GptOssParser::new()));
}
// Register default model mappings
Self::register_default_mappings(&registry);
......@@ -304,10 +293,6 @@ impl ParserFactory {
registry.map_model("Kimi-K2*", "kimik2");
registry.map_model("moonshot*/Kimi-K2*", "kimik2");
// GPT-OSS models
registry.map_model("gpt-oss*", "gpt_oss");
registry.map_model("t4-*", "gpt_oss");
// Other models
registry.map_model("gemini-*", "json");
registry.map_model("palm-*", "json");
......@@ -392,16 +377,3 @@ impl Default for ParserFactory {
Self::new()
}
}
fn use_harmony_gpt_oss() -> bool {
std::env::var("ROUTER_USE_HARMONY_GPT_OSS")
.ok()
.map(|value| {
let normalized = value.trim();
matches!(
normalized,
"1" | "true" | "TRUE" | "True" | "yes" | "YES" | "Yes" | "on" | "ON" | "On"
)
})
.unwrap_or(false)
}
sgl-router/src/tool_parser/mod.rs
View file @ 4463e90d
......@@ -20,8 +20,8 @@ pub use errors::{ParserError, ParserResult};
pub use factory::{ParserFactory, ParserRegistry, PooledParser};
// Re-export parsers for convenience
pub use parsers::{
DeepSeekParser, Glm4MoeParser, GptOssParser, JsonParser, KimiK2Parser, LlamaParser,
MistralParser, PythonicParser, QwenParser, Step3Parser,
DeepSeekParser, Glm4MoeParser, JsonParser, KimiK2Parser, LlamaParser, MistralParser,
PythonicParser, QwenParser, Step3Parser,
};
pub use traits::{PartialJsonParser, ToolParser};
pub use types::{FunctionCall, PartialToolCall, StreamingParseResult, ToolCall};
sgl-router/src/tool_parser/parsers/gpt_oss_harmony_parser.rs deleted 100644 → 0
View file @ 229f236d
use async_trait::async_trait;
use crate::{
protocols::common::Tool,
tool_parser::{
errors::ParserResult,
traits::{TokenToolParser, ToolParser},
types::{StreamingParseResult, ToolCall},
},
};
/// Placeholder for the Harmony-backed GPT-OSS parser.
///
/// regex implementation. This struct will be fleshed out in subsequent phases to
/// reuse Harmony's tokenizer and message reconstruction logic.
#[derive(Default)]
pub struct GptOssHarmonyParser;
impl GptOssHarmonyParser {
pub fn new() -> Self {
Self
}
}
#[async_trait]
impl ToolParser for GptOssHarmonyParser {
async fn parse_complete(&self, output: &str) -> ParserResult<(String, Vec<ToolCall>)> {
// Temporary stub: fall back to returning the raw text with no tool calls.
// Later phases will decode Harmony tokens into structured tool calls.
Ok((output.to_string(), Vec::new()))
}
async fn parse_incremental(
&mut self,
_chunk: &str,
_tools: &[Tool],
) -> ParserResult<StreamingParseResult> {
// Temporary stub until the Harmony streaming pipeline is implemented.
Ok(StreamingParseResult::default())
}
fn has_tool_markers(&self, text: &str) -> bool {
// Reuse the legacy heuristics for now; this will be replaced with Harmony-specific
// start-token detection when the parser is fully implemented.
text.contains("<|channel|>commentary")
}
fn as_token_parser(&self) -> Option<&dyn TokenToolParser> {
Some(self)
}
}
#[async_trait]
impl TokenToolParser for GptOssHarmonyParser {
async fn parse_complete_tokens(
&self,
_tokens: &[u32],
) -> ParserResult<(String, Vec<ToolCall>)> {
// Placeholder until Harmony integration lands. Returning an empty tool list ensures
// that enabling the parser without full implementation results in a no-op rather
// than a runtime panic.
Ok((String::new(), Vec::new()))
}
async fn parse_incremental_tokens(
&mut self,
_tokens: &[u32],
_tools: &[Tool],
) -> ParserResult<StreamingParseResult> {
Ok(StreamingParseResult::default())
}
}
sgl-router/src/tool_parser/parsers/gpt_oss_parser.rs deleted 100644 → 0
View file @ 229f236d
use async_trait::async_trait;
use regex::Regex;
use serde_json::Value;
use crate::{
protocols::common::Tool,
tool_parser::{
errors::{ParserError, ParserResult},
parsers::helpers,
partial_json::PartialJson,
traits::ToolParser,
types::{FunctionCall, StreamingParseResult, ToolCall, ToolCallItem},
},
};
/// GPT-OSS format parser for tool calls
///
/// Handles the GPT-OSS specific channel format:
/// `<|channel|>commentary to={namespace.function}<|constrain|>json<|message|>{json_args}<|call|>`
///
/// Features:
/// - Channel-based format with commentary
/// - Namespaced function calls
/// - JSON arguments
pub struct GptOssParser {
/// Parser for handling incomplete JSON during streaming
partial_json: PartialJson,
/// Regex for extracting complete function calls
function_call_extractor: Regex,
/// Regex for extracting streaming function calls
streaming_extractor: Regex,
/// Buffer for accumulating chunks
buffer: String,
/// Whether the tool name has been sent (for streaming)
name_sent: bool,
}
impl GptOssParser {
/// Create a new GPT-OSS parser
pub fn new() -> Self {
// Pattern for complete function calls with to= parameter
// Handles optional <|start|>assistant prefix and whitespace after function name
let function_call_pattern = r"(?s)(?:<\|start\|>assistant)?<\|channel\|>commentary to=([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_-]*)*)\s*<\|constrain\|>json<\|message\|>(.*?)<\|call\|>(?:commentary)?";
let function_call_extractor =
Regex::new(function_call_pattern).expect("Valid regex pattern");
// Pattern for streaming function calls (incomplete)
let streaming_pattern = r"(?s)(?:<\|start\|>assistant)?<\|channel\|>commentary to=([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_-]*)*)\s*<\|constrain\|>json<\|message\|>(.*)";
let streaming_extractor = Regex::new(streaming_pattern).expect("Valid regex pattern");
Self {
partial_json: PartialJson::default(),
function_call_extractor,
streaming_extractor,
buffer: String::new(),
name_sent: false,
}
}
/// Extract function name from full namespace (e.g., "functions.get_weather" -> "get_weather")
fn extract_function_name(&self, full_name: &str) -> String {
if let Some(dot_pos) = full_name.rfind('.') {
full_name[dot_pos + 1..].to_string()
} else {
full_name.to_string()
}
}
}
impl Default for GptOssParser {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl ToolParser for GptOssParser {
async fn parse_complete(&self, text: &str) -> ParserResult<(String, Vec<ToolCall>)> {
// Check if text contains GPT-OSS format
if !self.has_tool_markers(text) {
return Ok((text.to_string(), vec![]));
}
let mut tools = Vec::new();
let mut _tool_index = 0;
// Extract all function calls
for captures in self.function_call_extractor.captures_iter(text) {
if let (Some(name_match), Some(args_match)) = (captures.get(1), captures.get(2)) {
let full_function_name = name_match.as_str();
let args_content = args_match.as_str().trim();
// Extract actual function name
let function_name = self.extract_function_name(full_function_name);
// Parse JSON arguments
let arguments = if args_content.is_empty() {
"{}".to_string()
} else {
match serde_json::from_str::<Value>(args_content) {
Ok(value) => serde_json::to_string(&value)
.map_err(|e| ParserError::ParsingFailed(e.to_string()))?,
Err(_) => {
// Skip malformed JSON
continue;
}
}
};
tools.push(ToolCall {
function: FunctionCall {
name: function_name,
arguments,
},
});
_tool_index += 1;
}
}
Ok((String::new(), tools)) // GPT-OSS parser returns empty normal text
}
async fn parse_incremental(
&mut self,
chunk: &str,
tools: &[Tool],
) -> ParserResult<StreamingParseResult> {
self.buffer.push_str(chunk);
// Check for tool markers
if !self.has_tool_markers(&self.buffer) {
// No markers found, clear buffer and return
self.buffer.clear();
return Ok(StreamingParseResult::default());
}
// Try to match streaming pattern
if let Some(captures) = self.streaming_extractor.captures(&self.buffer) {
if let (Some(name_match), Some(args_match)) = (captures.get(1), captures.get(2)) {
let full_function_name = name_match.as_str();
let partial_args = args_match.as_str();
// Extract actual function name
let function_name = self.extract_function_name(full_function_name);
// Send function name if not sent yet
if !self.name_sent {
// Validate tool name
let tool_indices = helpers::get_tool_indices(tools);
if !tool_indices.contains_key(&function_name) {
// Invalid tool name - skip
tracing::warn!("Invalid tool name '{}' - skipping", function_name);
self.buffer.clear();
self.name_sent = false;
return Ok(StreamingParseResult::default());
}
self.name_sent = true; // Mark name as sent
return Ok(StreamingParseResult {
normal_text: String::new(),
calls: vec![ToolCallItem {
tool_index: 0,
name: Some(function_name.clone()),
parameters: String::new(),
}],
});
}
// Check if we have a complete function call
if let Some(complete_match) = self.function_call_extractor.captures(&self.buffer) {
if let Some(args_match) = complete_match.get(2) {
let args_content = args_match.as_str().trim();
// Parse JSON arguments
let arguments = if args_content.is_empty() {
"{}".to_string()
} else {
match serde_json::from_str::<Value>(args_content) {
Ok(value) => serde_json::to_string(&value)
.unwrap_or_else(|_| "{}".to_string()),
Err(_) => "{}".to_string(),
}
};
// Remove the processed part from buffer
let complete_end = complete_match.get(0).unwrap().end();
self.buffer.drain(..complete_end);
// Reset state for next tool
self.name_sent = false;
// Return final arguments
return Ok(StreamingParseResult {
normal_text: String::new(),
calls: vec![ToolCallItem {
tool_index: 0,
name: None,
parameters: arguments,
}],
});
}
} else {
// Try to parse partial JSON for streaming arguments
if !partial_args.is_empty() {
// Look for the end of JSON (before <|call|>)
let json_part = if let Some(call_pos) = partial_args.find("<|call|>") {
&partial_args[..call_pos]
} else {
partial_args
};
match self.partial_json.parse_value(json_part, true) {
Ok((value, _consumed)) => {
let args_str = serde_json::to_string(&value)
.unwrap_or_else(|_| "{}".to_string());
return Ok(StreamingParseResult {
normal_text: String::new(),
calls: vec![ToolCallItem {
tool_index: 0,
name: None,
parameters: args_str,
}],
});
}
Err(_) => {
// Can't parse yet, keep buffering
}
}
}
}
}
}
Ok(StreamingParseResult::default())
}
fn has_tool_markers(&self, text: &str) -> bool {
text.contains("<|channel|>commentary")
}
}
sgl-router/src/tool_parser/parsers/mod.rs
View file @ 4463e90d
......@@ -3,32 +3,28 @@
/// This module contains concrete parser implementations for various model-specific
/// tool/function call formats.
// Individual parser modules
pub mod deepseek_parser;
pub mod glm4_moe_parser;
pub mod gpt_oss_harmony_parser;
pub mod gpt_oss_parser;
pub mod json_parser;
pub mod kimik2_parser;
pub mod llama_parser;
pub mod mistral_parser;
pub mod passthrough_parser;
pub mod pythonic_parser;
pub mod qwen_parser;
pub mod step3_parser;
pub mod deepseek;
pub mod glm4_moe;
pub mod json;
pub mod kimik2;
pub mod llama;
pub mod mistral;
pub mod passthrough;
pub mod pythonic;
pub mod qwen;
pub mod step3;
// Shared helpers and utilities
pub mod helpers;
// Re-export parser types for convenience
pub use deepseek_parser::DeepSeekParser;
pub use glm4_moe_parser::Glm4MoeParser;
pub use gpt_oss_harmony_parser::GptOssHarmonyParser;
pub use gpt_oss_parser::GptOssParser;
pub use json_parser::JsonParser;
pub use kimik2_parser::KimiK2Parser;
pub use llama_parser::LlamaParser;
pub use mistral_parser::MistralParser;
pub use passthrough_parser::PassthroughParser;
pub use pythonic_parser::PythonicParser;
pub use qwen_parser::QwenParser;
pub use step3_parser::Step3Parser;
pub use deepseek::DeepSeekParser;
pub use glm4_moe::Glm4MoeParser;
pub use json::JsonParser;
pub use kimik2::KimiK2Parser;
pub use llama::LlamaParser;
pub use mistral::MistralParser;
pub use passthrough::PassthroughParser;
pub use pythonic::PythonicParser;
pub use qwen::QwenParser;
pub use step3::Step3Parser;
sgl-router/tests/tool_parser_gpt_oss.rs deleted 100644 → 0
View file @ 229f236d
//! GPT-OSS Parser Integration Tests
use sglang_router_rs::tool_parser::{GptOssParser, ToolParser};
mod common;
use common::create_test_tools;
#[tokio::test]
async fn test_gpt_oss_complete_parsing() {
let parser = GptOssParser::new();
let input = r#"Let me search for that information.
<|channel|>commentary to=functions.search<|constrain|>json<|message|>{"query": "rust programming", "limit": 10}<|call|>
Here are the results..."#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 1);
assert_eq!(tools[0].function.name, "search");
let args: serde_json::Value = serde_json::from_str(&tools[0].function.arguments).unwrap();
assert_eq!(args["query"], "rust programming");
assert_eq!(args["limit"], 10);
}
#[tokio::test]
async fn test_gpt_oss_multiple_tools() {
let parser = GptOssParser::new();
let input = r#"<|channel|>commentary to=functions.get_weather<|constrain|>json<|message|>{"location": "Paris"}<|call|>commentary
<|channel|>commentary to=functions.search<|constrain|>json<|message|>{"query": "Paris tourism"}<|call|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 2);
assert_eq!(tools[0].function.name, "get_weather");
assert_eq!(tools[1].function.name, "search");
}
#[tokio::test]
async fn test_gpt_oss_with_namespace() {
let parser = GptOssParser::new();
let input = r#"<|channel|>commentary to=api.users.create<|constrain|>json<|message|>{"name": "John", "email": "john@example.com"}<|call|>
<|channel|>commentary to=tools.calculator.add<|constrain|>json<|message|>{"x": 10, "y": 20}<|call|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 2);
assert_eq!(tools[0].function.name, "create"); // Should extract last part
assert_eq!(tools[1].function.name, "add");
}
#[tokio::test]
async fn test_gpt_oss_with_assistant_prefix() {
let parser = GptOssParser::new();
let input = r#"<|start|>assistant<|channel|>commentary to=functions.test<|constrain|>json<|message|>{"key": "value"}<|call|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 1);
assert_eq!(tools[0].function.name, "test");
}
#[tokio::test]
async fn test_gpt_oss_empty_args() {
let parser = GptOssParser::new();
let input =
r#"<|channel|>commentary to=functions.get_time<|constrain|>json<|message|>{}<|call|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 1);
assert_eq!(tools[0].function.name, "get_time");
assert_eq!(tools[0].function.arguments, "{}");
}
#[tokio::test]
async fn test_gpt_oss_streaming() {
let tools = create_test_tools();
let mut parser = GptOssParser::new();
// Simulate streaming chunks
let chunks = vec![
"<|channel|>commentary to=",
"functions.calculate",
"<|constrain|>json<|message|>",
r#"{"x": 10"#,
r#", "y": 20}"#,
"<|call|>",
];
let mut found_complete = false;
for chunk in chunks {
let result = parser.parse_incremental(chunk, &tools).await.unwrap();
if !result.calls.is_empty() {
if let Some(name) = &result.calls[0].name {
assert_eq!(name, "calculate");
found_complete = true;
}
}
}
assert!(found_complete);
}
#[test]
fn test_gpt_oss_format_detection() {
let parser = GptOssParser::new();
// Should detect GPT-OSS format
assert!(parser.has_tool_markers("<|channel|>commentary to="));
assert!(parser.has_tool_markers("<|channel|>commentary"));
assert!(parser.has_tool_markers("text with <|channel|>commentary to= marker"));
// Should not detect other formats
assert!(!parser.has_tool_markers("[TOOL_CALLS]"));
assert!(!parser.has_tool_markers("<tool_call>"));
assert!(!parser.has_tool_markers("plain text"));
}
#[tokio::test]
async fn test_gpt_oss_with_whitespace() {
let parser = GptOssParser::new();
let input = r#"<|channel|>commentary to=functions.test <|constrain|>json<|message|>{"key": "value"}<|call|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 1);
assert_eq!(tools[0].function.name, "test");
}
#[tokio::test]
async fn test_gpt_oss_complex_json() {
let parser = GptOssParser::new();
let input = r#"<|channel|>commentary to=functions.process<|constrain|>json<|message|>{
"nested": {
"data": [1, 2, 3],
"config": {
"enabled": true
}
}
}<|call|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 1);
assert_eq!(tools[0].function.name, "process");
let args: serde_json::Value = serde_json::from_str(&tools[0].function.arguments).unwrap();
assert!(args["nested"]["data"].is_array());
assert_eq!(args["nested"]["config"]["enabled"], true);
}
#[tokio::test]
async fn test_commentary_without_function() {
let parser = GptOssParser::new();
// Python should extract commentary as normal text
let input = r#"<|channel|>commentary<|message|>**Action plan**: 1. Do X 2. Do Y<|end|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 0); // No tool calls
// TODO: Verify normal text = "**Action plan**: 1. Do X 2. Do Y"
}
#[tokio::test]
async fn test_final_channel() {
let parser = GptOssParser::new();
let input = r#"<|channel|>commentary to=functions.test<|constrain|>json<|message|>{"x": 1}<|call|>
<|channel|>final<|message|>The result is calculated.<|return|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 1);
assert_eq!(tools[0].function.name, "test");
// TODO: Verify normal text = "The result is calculated."
}
#[tokio::test]
async fn test_mixed_commentary_and_calls() {
let parser = GptOssParser::new();
let input = r#"<|channel|>commentary<|message|>Let me think<|end|>
<|channel|>commentary to=functions.calc<|constrain|>json<|message|>{"x": 5}<|call|>
<|channel|>commentary<|message|>Processing...<|end|>"#;
let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
assert_eq!(tools.len(), 1);
assert_eq!(tools[0].function.name, "calc");
// TODO: Verify normal text = "Let me think Processing..."
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment