diff --git a/rust/src/tool-parser/benches/qwen3_coder.rs b/rust/src/tool-parser/benches/qwen3_coder.rs index 850badaac5..b4f26ac5cd 100644 --- a/rust/src/tool-parser/benches/qwen3_coder.rs +++ b/rust/src/tool-parser/benches/qwen3_coder.rs @@ -10,6 +10,7 @@ use utils::{feed_external_parser, feed_parser, openai_tools}; const CHUNK_CHARS: usize = 7; const LONG_NORMAL_TEXT_REPEATS: usize = 2048; +const LONG_TOOL_BODY_REPEATS: usize = 8192; fn mixed_fixture() -> String { concat!( @@ -39,6 +40,17 @@ fn long_normal_text_fixture() -> String { line.repeat(LONG_NORMAL_TEXT_REPEATS) } +fn long_tool_call_fixture() -> String { + let location = "x".repeat(LONG_TOOL_BODY_REPEATS); + format!( + "\n\ + \n\ + {location}\n\ + \n\ + " + ) +} + fn native_parser(tools: &[Tool]) -> Box { Qwen3CoderToolParser::create(tools).expect("Qwen Coder parser should initialize") } @@ -112,6 +124,7 @@ fn bench_qwen3_coder(c: &mut Criterion) { let tools = test_tools(); let mixed_text = mixed_fixture(); let long_normal_text = long_normal_text_fixture(); + let long_tool_call = long_tool_call_fixture(); run_stream_group( c, @@ -132,6 +145,16 @@ fn bench_qwen3_coder(c: &mut Criterion) { &long_normal_text, 0, ); + + run_stream_group( + c, + "qwen3_coder/long_tool_call_body", + &tools, + &long_tool_call, + CHUNK_CHARS, + "", + 1, + ); } criterion_group!(benches, bench_qwen3_coder); diff --git a/rust/src/tool-parser/src/deepseek_dsml/mod.rs b/rust/src/tool-parser/src/deepseek_dsml/mod.rs index b441351865..1a2031dd3d 100644 --- a/rust/src/tool-parser/src/deepseek_dsml/mod.rs +++ b/rust/src/tool-parser/src/deepseek_dsml/mod.rs @@ -5,7 +5,7 @@ use winnow::stream::Partial; use winnow::token::{literal, rest, take_until}; use super::parameters::ToolSchemas; -use super::utils::{parse_buffered_event, safe_text_len}; +use super::utils::{MarkerScanState, parse_buffered_event, safe_text_len, take_until_marker}; use super::{Result, ToolCallDelta, ToolParserOutput}; use crate::Tool; @@ -39,10 +39,10 @@ impl DsmlTokens { }; } -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq)] enum DsmlMode { Text, - ToolBlock, + ToolBlock { invoke_end_scan: MarkerScanState }, Done, } @@ -94,7 +94,11 @@ impl DeepSeekDsmlToolParser { DsmlEvent::Text { len: consumed_len } => { output.normal_text.push_str(&self.buffer[..consumed_len]); } - DsmlEvent::ToolCallsStart => self.mode = DsmlMode::ToolBlock, + DsmlEvent::ToolCallsStart => { + self.mode = DsmlMode::ToolBlock { + invoke_end_scan: MarkerScanState::default(), + }; + } DsmlEvent::Invoke { name, raw_params } => { let mut arguments = serde_json::Map::with_capacity(raw_params.len()); for param in raw_params { @@ -140,7 +144,7 @@ impl DeepSeekDsmlToolParser { self.buffer.push_str(chunk); while let Some((event, consumed_len)) = parse_buffered_event(&self.buffer, |input| { - parse_next_dsml_event(input, self.mode, self.tokens) + parse_next_dsml_event(input, &mut self.mode, self.tokens) })? { self.apply_event(event, output)?; self.buffer.drain(..consumed_len); @@ -154,7 +158,7 @@ impl DeepSeekDsmlToolParser { match self.mode { DsmlMode::Text => output.normal_text.push_str(&self.buffer), DsmlMode::Done => {} - DsmlMode::ToolBlock => { + DsmlMode::ToolBlock { .. } => { return Err(parsing_failed!("incomplete DeepSeek DSML tool call")); } } @@ -166,12 +170,14 @@ impl DeepSeekDsmlToolParser { /// Parse a DSML event for the current parser mode. fn parse_next_dsml_event( input: &mut DsmlInput<'_>, - mode: DsmlMode, + mode: &mut DsmlMode, tokens: DsmlTokens, ) -> ModalResult { match mode { DsmlMode::Text => parse_text_event(input, tokens), - DsmlMode::ToolBlock => parse_tool_block_event(input, tokens), + DsmlMode::ToolBlock { invoke_end_scan } => { + parse_tool_block_event(input, tokens, invoke_end_scan) + } DsmlMode::Done => ignored_rest_event(input), } } @@ -186,11 +192,16 @@ fn parse_text_event(input: &mut DsmlInput<'_>, tokens: DsmlTokens) -> ModalResul } /// Parse a tool-block DSML event. -fn parse_tool_block_event(input: &mut DsmlInput<'_>, tokens: DsmlTokens) -> ModalResult { +fn parse_tool_block_event( + input: &mut DsmlInput<'_>, + tokens: DsmlTokens, + invoke_end_scan: &mut MarkerScanState, +) -> ModalResult { ws0.void().parse_next(input)?; - alt((invoke_event, |input: &mut DsmlInput<'_>| { - tool_calls_end_event(input, tokens) - })) + alt(( + |input: &mut DsmlInput<'_>| invoke_event(input, invoke_end_scan), + |input: &mut DsmlInput<'_>| tool_calls_end_event(input, tokens), + )) .parse_next(input) } @@ -217,14 +228,17 @@ fn safe_text_event(input: &mut DsmlInput<'_>, tokens: DsmlTokens) -> ModalResult } /// Parse a DSML invoke block. -fn invoke_event(input: &mut DsmlInput<'_>) -> ModalResult { +fn invoke_event( + input: &mut DsmlInput<'_>, + invoke_end_scan: &mut MarkerScanState, +) -> ModalResult { let (name, body) = seq!( _: literal(INVOKE_START), _: ws1, dsml_name_attr, _: ws0, _: ">", - take_until(0.., INVOKE_END), + take_until_marker(INVOKE_END, invoke_end_scan), _: literal(INVOKE_END), ) .parse_next(input)?; diff --git a/rust/src/tool-parser/src/glm_xml/mod.rs b/rust/src/tool-parser/src/glm_xml/mod.rs index 9a5a39dabb..ceeb9a7517 100644 --- a/rust/src/tool-parser/src/glm_xml/mod.rs +++ b/rust/src/tool-parser/src/glm_xml/mod.rs @@ -5,7 +5,7 @@ use winnow::stream::Partial; use winnow::token::{literal, rest, take_until, take_while}; use super::parameters::ToolSchemas; -use super::utils::{parse_buffered_event, safe_text_len}; +use super::utils::{MarkerScanState, parse_buffered_event, safe_text_len, take_until_marker}; use super::{Result, ToolCallDelta, ToolParserOutput}; use crate::Tool; @@ -24,10 +24,10 @@ const ARG_VALUE_END: &str = ""; type GlmInput<'i> = Partial<&'i str>; -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq)] enum GlmMode { Text, - ToolCall, + ToolCall { tool_call_end_scan: MarkerScanState }, AfterToolCall, } @@ -81,7 +81,11 @@ impl GlmXmlToolParser { GlmEvent::Text { len: consumed_len } => { output.normal_text.push_str(&self.buffer[..consumed_len]); } - GlmEvent::ToolCallStart => self.mode = GlmMode::ToolCall, + GlmEvent::ToolCallStart => { + self.mode = GlmMode::ToolCall { + tool_call_end_scan: MarkerScanState::default(), + }; + } GlmEvent::ToolCall { name, raw_params } => { self.mode = GlmMode::AfterToolCall; let arguments = self.tool_parameters.convert_params_with_schema(&name, raw_params); @@ -110,7 +114,7 @@ impl GlmXmlToolParser { self.buffer.push_str(chunk); while let Some((event, consumed_len)) = parse_buffered_event(&self.buffer, |input| { - parse_next_glm_event(input, self.mode, self.separator) + parse_next_glm_event(input, &mut self.mode, self.separator) })? { self.apply_event(event, output)?; self.buffer.drain(..consumed_len); @@ -124,7 +128,9 @@ impl GlmXmlToolParser { if !self.buffer.is_empty() { match self.mode { GlmMode::Text => output.normal_text.push_str(&self.buffer), - GlmMode::ToolCall => return Err(parsing_failed!("incomplete GLM MoE tool call")), + GlmMode::ToolCall { .. } => { + return Err(parsing_failed!("incomplete GLM MoE tool call")); + } GlmMode::AfterToolCall => {} } } @@ -136,12 +142,14 @@ impl GlmXmlToolParser { /// Parse a GLM event for the current parser mode. fn parse_next_glm_event( input: &mut GlmInput<'_>, - mode: GlmMode, + mode: &mut GlmMode, separator: Separator, ) -> ModalResult { match mode { GlmMode::Text => parse_text_event(input), - GlmMode::ToolCall => tool_call_event(input, separator), + GlmMode::ToolCall { tool_call_end_scan } => { + tool_call_event(input, separator, tool_call_end_scan) + } GlmMode::AfterToolCall => after_tool_call_event(input), } } @@ -173,9 +181,13 @@ fn ignored_rest_event(input: &mut GlmInput<'_>) -> ModalResult { } /// Parse a complete GLM tool call. -fn tool_call_event(input: &mut GlmInput<'_>, separator: Separator) -> ModalResult { +fn tool_call_event( + input: &mut GlmInput<'_>, + separator: Separator, + tool_call_end_scan: &mut MarkerScanState, +) -> ModalResult { let (body,) = seq!( - take_until(0.., TOOL_CALL_END), + take_until_marker(TOOL_CALL_END, tool_call_end_scan), _: literal(TOOL_CALL_END), ) .parse_next(input)?; diff --git a/rust/src/tool-parser/src/hy_v3.rs b/rust/src/tool-parser/src/hy_v3.rs index 32f0e4d9e7..7c850d51aa 100644 --- a/rust/src/tool-parser/src/hy_v3.rs +++ b/rust/src/tool-parser/src/hy_v3.rs @@ -5,7 +5,7 @@ use winnow::stream::Partial; use winnow::token::{literal, rest, take_until}; use super::parameters::ToolSchemas; -use super::utils::{parse_buffered_event, safe_text_len}; +use super::utils::{MarkerScanState, parse_buffered_event, safe_text_len, take_until_marker}; use super::{Result, ToolCallDelta, ToolParser, ToolParserOutput}; use crate::Tool; @@ -21,10 +21,10 @@ const ARG_VALUE_END: &str = ""; type HyV3Input<'i> = Partial<&'i str>; -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq)] enum HyV3Mode { Text, - ToolBlock, + ToolBlock { tool_call_end_scan: MarkerScanState }, Done, } @@ -81,7 +81,11 @@ impl HyV3ToolParser { HyV3Event::Text { len: consumed_len } => { output.normal_text.push_str(&self.buffer[..consumed_len]); } - HyV3Event::ToolBlockStart => self.mode = HyV3Mode::ToolBlock, + HyV3Event::ToolBlockStart => { + self.mode = HyV3Mode::ToolBlock { + tool_call_end_scan: MarkerScanState::default(), + }; + } HyV3Event::ToolCall { name, raw_params } => { let arguments = self.tool_parameters.convert_params_with_schema(&name, raw_params); let arguments = serde_json::to_string(&arguments) @@ -113,7 +117,7 @@ impl ToolParser for HyV3ToolParser { self.buffer.push_str(chunk); while let Some((event, consumed_len)) = parse_buffered_event(&self.buffer, |input| { - parse_next_hy_v3_event(input, self.mode) + parse_next_hy_v3_event(input, &mut self.mode) })? { self.apply_event(event, output)?; self.buffer.drain(..consumed_len); @@ -126,7 +130,7 @@ impl ToolParser for HyV3ToolParser { let mut output = ToolParserOutput::default(); match self.mode { HyV3Mode::Text => output.normal_text.push_str(&self.buffer), - HyV3Mode::ToolBlock => return Err(parsing_failed!("incomplete HY3 tool call")), + HyV3Mode::ToolBlock { .. } => return Err(parsing_failed!("incomplete HY3 tool call")), HyV3Mode::Done => {} } let _ = self.reset(); @@ -141,10 +145,15 @@ impl ToolParser for HyV3ToolParser { } /// Parse a HY3 event for the current parser mode. -fn parse_next_hy_v3_event(input: &mut HyV3Input<'_>, mode: HyV3Mode) -> ModalResult { +fn parse_next_hy_v3_event( + input: &mut HyV3Input<'_>, + mode: &mut HyV3Mode, +) -> ModalResult { match mode { HyV3Mode::Text => parse_text_event(input), - HyV3Mode::ToolBlock => parse_tool_block_event(input), + HyV3Mode::ToolBlock { tool_call_end_scan } => { + parse_tool_block_event(input, tool_call_end_scan) + } HyV3Mode::Done => ignored_rest_event(input), } } @@ -165,8 +174,14 @@ fn safe_text_event(input: &mut HyV3Input<'_>) -> ModalResult { } /// Parse one event inside a HY3 tool block. -fn parse_tool_block_event(input: &mut HyV3Input<'_>) -> ModalResult { - alt((tool_block_end_event, tool_call_event)).parse_next(input) +fn parse_tool_block_event( + input: &mut HyV3Input<'_>, + tool_call_end_scan: &mut MarkerScanState, +) -> ModalResult { + alt((tool_block_end_event, |input: &mut HyV3Input<'_>| { + tool_call_event(input, tool_call_end_scan) + })) + .parse_next(input) } /// Parse a HY3 tool-block end marker. @@ -175,13 +190,16 @@ fn tool_block_end_event(input: &mut HyV3Input<'_>) -> ModalResult { } /// Parse a complete HY3 tool-call block. -fn tool_call_event(input: &mut HyV3Input<'_>) -> ModalResult { +fn tool_call_event( + input: &mut HyV3Input<'_>, + tool_call_end_scan: &mut MarkerScanState, +) -> ModalResult { let (name, body) = seq!( _: ws0, _: literal(TOOL_CALL_START), take_until(0.., TOOL_SEP), _: literal(TOOL_SEP), - take_until(0.., TOOL_CALL_END), + take_until_marker(TOOL_CALL_END, tool_call_end_scan), _: literal(TOOL_CALL_END), ) .parse_next(input)?; diff --git a/rust/src/tool-parser/src/minimax_m2.rs b/rust/src/tool-parser/src/minimax_m2.rs index 4cd371740c..1d7bc78987 100644 --- a/rust/src/tool-parser/src/minimax_m2.rs +++ b/rust/src/tool-parser/src/minimax_m2.rs @@ -5,7 +5,7 @@ use winnow::stream::Partial; use winnow::token::{literal, rest, take_until}; use super::parameters::ToolSchemas; -use super::utils::{parse_buffered_event, safe_text_len}; +use super::utils::{MarkerScanState, parse_buffered_event, safe_text_len, take_until_marker}; use super::{Result, ToolCallDelta, ToolParser, ToolParserOutput}; use crate::Tool; @@ -18,10 +18,10 @@ const PARAMETER_END: &str = ""; type MinimaxM2Input<'i> = Partial<&'i str>; -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq)] enum MinimaxM2Mode { Text, - ToolBlock, + ToolBlock { invoke_end_scan: MarkerScanState }, Done, } @@ -74,7 +74,11 @@ impl MinimaxM2ToolParser { MinimaxM2Event::Text { len: consumed_len } => { output.normal_text.push_str(&self.buffer[..consumed_len]); } - MinimaxM2Event::ToolBlockStart => self.mode = MinimaxM2Mode::ToolBlock, + MinimaxM2Event::ToolBlockStart => { + self.mode = MinimaxM2Mode::ToolBlock { + invoke_end_scan: MarkerScanState::default(), + }; + } MinimaxM2Event::Invoke { name, raw_params } => { let arguments = self.tool_parameters.convert_params_with_schema(&name, raw_params); let arguments = serde_json::to_string(&arguments) @@ -112,7 +116,7 @@ impl ToolParser for MinimaxM2ToolParser { self.buffer.push_str(chunk); while let Some((event, consumed_len)) = parse_buffered_event(&self.buffer, |input| { - parse_next_minimax_m2_event(input, self.mode) + parse_next_minimax_m2_event(input, &mut self.mode) })? { self.apply_event(event, output)?; self.buffer.drain(..consumed_len); @@ -127,7 +131,7 @@ impl ToolParser for MinimaxM2ToolParser { MinimaxM2Mode::Text => { output.normal_text.push_str(&self.buffer); } - MinimaxM2Mode::ToolBlock => { + MinimaxM2Mode::ToolBlock { .. } => { return Err(parsing_failed!("incomplete MiniMax M2 tool call")); } MinimaxM2Mode::Done => {} @@ -144,11 +148,13 @@ impl ToolParser for MinimaxM2ToolParser { /// Parse a MiniMax M2 event for the current parser mode. fn parse_next_minimax_m2_event( input: &mut MinimaxM2Input<'_>, - mode: MinimaxM2Mode, + mode: &mut MinimaxM2Mode, ) -> ModalResult { match mode { MinimaxM2Mode::Text => parse_text_event(input), - MinimaxM2Mode::ToolBlock => parse_tool_block_event(input), + MinimaxM2Mode::ToolBlock { invoke_end_scan } => { + parse_tool_block_event(input, invoke_end_scan) + } MinimaxM2Mode::Done => ignored_rest_event(input), } } @@ -169,8 +175,14 @@ fn safe_text_event(input: &mut MinimaxM2Input<'_>) -> ModalResult) -> ModalResult { - alt((tool_block_end_event, invoke_event)).parse_next(input) +fn parse_tool_block_event( + input: &mut MinimaxM2Input<'_>, + invoke_end_scan: &mut MarkerScanState, +) -> ModalResult { + alt((tool_block_end_event, |input: &mut MinimaxM2Input<'_>| { + invoke_event(input, invoke_end_scan) + })) + .parse_next(input) } /// Parse a MiniMax M2 tool-block end marker. @@ -181,14 +193,17 @@ fn tool_block_end_event(input: &mut MinimaxM2Input<'_>) -> ModalResult) -> ModalResult { +fn invoke_event( + input: &mut MinimaxM2Input<'_>, + invoke_end_scan: &mut MarkerScanState, +) -> ModalResult { let (name, body) = seq!( _: ws0, _: literal(INVOKE_START), _: (ws1, literal("name=")), partial_attr_value, _: literal(">"), - take_until(0.., INVOKE_END), + take_until_marker(INVOKE_END, invoke_end_scan), _: literal(INVOKE_END), ) .parse_next(input)?; diff --git a/rust/src/tool-parser/src/minimax_m3.rs b/rust/src/tool-parser/src/minimax_m3.rs index ac79ec1a57..ad40a7f18b 100644 --- a/rust/src/tool-parser/src/minimax_m3.rs +++ b/rust/src/tool-parser/src/minimax_m3.rs @@ -6,7 +6,7 @@ use winnow::stream::Partial; use winnow::token::{literal, rest, take_until}; use super::parameters::{ParamElement, ParamInput, ToolSchemas}; -use super::utils::{parse_buffered_event, safe_text_len}; +use super::utils::{MarkerScanState, parse_buffered_event, safe_text_len, take_until_marker}; use super::{Result, ToolCallDelta, ToolParser, ToolParserOutput}; use crate::Tool; @@ -21,10 +21,10 @@ const MIXED_TEXT_FIELD: &str = "$text"; type MinimaxM3Input<'i> = Partial<&'i str>; -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq)] enum MinimaxM3Mode { Text, - ToolBlock, + ToolBlock { invoke_end_scan: MarkerScanState }, Done, } @@ -109,7 +109,11 @@ impl MinimaxM3ToolParser { MinimaxM3Event::Text { len: consumed_len } => { output.normal_text.push_str(&self.buffer[..consumed_len]); } - MinimaxM3Event::ToolBlockStart => self.mode = MinimaxM3Mode::ToolBlock, + MinimaxM3Event::ToolBlockStart => { + self.mode = MinimaxM3Mode::ToolBlock { + invoke_end_scan: MarkerScanState::default(), + }; + } MinimaxM3Event::Invoke { name, params } => { let arguments = self.tool_parameters.convert_params_with_schema(&name, params); let arguments = serde_json::to_string(&arguments) @@ -141,7 +145,7 @@ impl ToolParser for MinimaxM3ToolParser { self.buffer.push_str(chunk); while let Some((event, consumed_len)) = parse_buffered_event(&self.buffer, |input| { - parse_next_minimax_m3_event(input, self.mode) + parse_next_minimax_m3_event(input, &mut self.mode) })? { self.apply_event(event, output)?; self.buffer.drain(..consumed_len); @@ -156,7 +160,7 @@ impl ToolParser for MinimaxM3ToolParser { MinimaxM3Mode::Text => { output.normal_text.push_str(&self.buffer); } - MinimaxM3Mode::ToolBlock => { + MinimaxM3Mode::ToolBlock { .. } => { if !self.buffer.trim_start().is_empty() { return Err(parsing_failed!("incomplete MiniMax M3 tool call")); } @@ -177,11 +181,13 @@ impl ToolParser for MinimaxM3ToolParser { /// Parse a MiniMax M3 event for the current parser mode. fn parse_next_minimax_m3_event( input: &mut MinimaxM3Input<'_>, - mode: MinimaxM3Mode, + mode: &mut MinimaxM3Mode, ) -> ModalResult { match mode { MinimaxM3Mode::Text => parse_text_event(input), - MinimaxM3Mode::ToolBlock => parse_tool_block_event(input), + MinimaxM3Mode::ToolBlock { invoke_end_scan } => { + parse_tool_block_event(input, invoke_end_scan) + } MinimaxM3Mode::Done => ignored_rest_event(input), } } @@ -202,8 +208,14 @@ fn safe_text_event(input: &mut MinimaxM3Input<'_>) -> ModalResult) -> ModalResult { - alt((tool_block_end_event, invoke_event)).parse_next(input) +fn parse_tool_block_event( + input: &mut MinimaxM3Input<'_>, + invoke_end_scan: &mut MarkerScanState, +) -> ModalResult { + alt((tool_block_end_event, |input: &mut MinimaxM3Input<'_>| { + invoke_event(input, invoke_end_scan) + })) + .parse_next(input) } /// Parse a MiniMax M3 tool-block end marker. @@ -214,14 +226,17 @@ fn tool_block_end_event(input: &mut MinimaxM3Input<'_>) -> ModalResult) -> ModalResult { +fn invoke_event( + input: &mut MinimaxM3Input<'_>, + invoke_end_scan: &mut MarkerScanState, +) -> ModalResult { let (name, body) = seq!( _: ws0, _: literal(INVOKE_START), _: (ws1, literal("name=")), partial_attr_value, _: literal(">"), - take_until(0.., INVOKE_END), + take_until_marker(INVOKE_END, invoke_end_scan), _: literal(INVOKE_END), ) .parse_next(input)?; diff --git a/rust/src/tool-parser/src/qwen_coder.rs b/rust/src/tool-parser/src/qwen_coder.rs index 0a2bcd4161..270955aff0 100644 --- a/rust/src/tool-parser/src/qwen_coder.rs +++ b/rust/src/tool-parser/src/qwen_coder.rs @@ -5,7 +5,7 @@ use winnow::stream::Partial; use winnow::token::{literal, take_until}; use super::parameters::ToolSchemas; -use super::utils::{parse_buffered_event, safe_text_len}; +use super::utils::{MarkerScanState, parse_buffered_event, safe_text_len, take_until_marker}; use super::{Result, ToolCallDelta, ToolParser, ToolParserOutput}; use crate::Tool; @@ -18,10 +18,10 @@ const PARAMETER_END: &str = ""; type QwenCoderInput<'i> = Partial<&'i str>; -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq)] enum QwenCoderMode { Text, - ToolCall, + ToolCall { end_marker_scan: MarkerScanState }, } #[derive(Debug, Clone, PartialEq, Eq)] @@ -76,7 +76,11 @@ impl Qwen3CoderToolParser { QwenCoderEvent::Text { len: consumed_len } => { output.normal_text.push_str(&self.buffer[..consumed_len]); } - QwenCoderEvent::ToolCallStart => self.mode = QwenCoderMode::ToolCall, + QwenCoderEvent::ToolCallStart => { + self.mode = QwenCoderMode::ToolCall { + end_marker_scan: MarkerScanState::default(), + }; + } QwenCoderEvent::ToolCall { name, raw_params } => { self.mode = QwenCoderMode::Text; let arguments = self.tool_parameters.convert_params_with_schema(&name, raw_params); @@ -113,7 +117,7 @@ impl ToolParser for Qwen3CoderToolParser { self.buffer.push_str(chunk); while let Some((event, consumed_len)) = parse_buffered_event(&self.buffer, |input| { - parse_next_qwen_coder_event(input, self.mode) + parse_next_qwen_coder_event(input, &mut self.mode) })? { self.apply_event(event, output)?; self.buffer.drain(..consumed_len); @@ -125,7 +129,9 @@ impl ToolParser for Qwen3CoderToolParser { fn finish(&mut self) -> Result { let mut output = ToolParserOutput::default(); if !self.buffer.is_empty() { - if self.mode == QwenCoderMode::ToolCall || self.buffer.starts_with(TOOL_CALL_START) { + if matches!(self.mode, QwenCoderMode::ToolCall { .. }) + || self.buffer.starts_with(TOOL_CALL_START) + { return Err(parsing_failed!("incomplete Qwen Coder tool call")); } output.normal_text.push_str(&self.buffer); @@ -142,11 +148,11 @@ impl ToolParser for Qwen3CoderToolParser { /// Parse a Qwen Coder event for the current parser mode. fn parse_next_qwen_coder_event( input: &mut QwenCoderInput<'_>, - mode: QwenCoderMode, + mode: &mut QwenCoderMode, ) -> ModalResult { match mode { QwenCoderMode::Text => parse_text_event(input), - QwenCoderMode::ToolCall => tool_call_event(input), + QwenCoderMode::ToolCall { end_marker_scan } => tool_call_event(input, end_marker_scan), } } @@ -166,10 +172,13 @@ fn safe_text_event(input: &mut QwenCoderInput<'_>) -> ModalResult) -> ModalResult { +fn tool_call_event( + input: &mut QwenCoderInput<'_>, + end_marker_scan: &mut MarkerScanState, +) -> ModalResult { let (body,) = seq!( _: ws0, - take_until(0.., TOOL_CALL_END), + take_until_marker(TOOL_CALL_END, end_marker_scan), _: literal(TOOL_CALL_END), ) .parse_next(input)?; @@ -228,8 +237,8 @@ mod tests { use thiserror_ext::AsReport; use super::{Qwen3CoderToolParser, ToolParser}; - use crate::ToolParserTestExt as _; use crate::test_utils::{collect_stream, split_by_chars, test_tools}; + use crate::{ToolParserOutput, ToolParserTestExt as _}; fn build_tool_call(function_name: &str, params: &[(&str, &str)]) -> String { let params = params @@ -574,6 +583,68 @@ mod tests { ); } + #[test] + fn qwen_coder_streaming_handles_end_token_split_across_chunks() { + let mut parser = Qwen3CoderToolParser::new(&test_tools()); + let output = parser + .parse_chunk( + "\n\ + \n\ + SF\n\ + \n\ + ").unwrap()); + output.append(parser.finish().unwrap()); + let output = output.coalesce_calls(); + + assert!(output.normal_text.is_empty()); + assert_eq!(output.calls.len(), 1); + assert_eq!(output.calls[0].name.as_deref(), Some("get_weather")); + assert_eq!( + serde_json::from_str::(&output.calls[0].arguments).unwrap(), + json!({ "location": "SF" }) + ); + } + + #[test] + fn qwen_coder_streaming_buffers_long_body_until_end_marker() { + let long_location = format!("SF-{}", "x".repeat(8192)); + let text = build_tool_call("get_weather", &[("location", &long_location)]); + let split_at = text.len() - "_call>".len(); + let (body_with_partial_end, end_suffix) = text.split_at(split_at); + let chunks = split_by_chars(body_with_partial_end, 31); + let mut parser = Qwen3CoderToolParser::new(&test_tools()); + let mut output = ToolParserOutput::default(); + + assert_eq!(end_suffix, "_call>"); + + for chunk in chunks { + let chunk_output = parser.parse_chunk(chunk).unwrap(); + assert!(chunk_output.normal_text.is_empty()); + assert!(chunk_output.calls.is_empty()); + output.append(chunk_output); + } + + output.append(parser.parse_chunk(end_suffix).unwrap()); + output.append(parser.finish().unwrap()); + let output = output.coalesce_calls(); + + assert!(output.normal_text.is_empty()); + assert_eq!(output.calls.len(), 1); + assert_eq!(output.calls[0].name.as_deref(), Some("get_weather")); + assert_eq!( + serde_json::from_str::(&output.calls[0].arguments).unwrap(), + json!({ "location": long_location }) + ); + } + #[test] fn qwen_coder_streaming_does_not_emit_incomplete_tool_call() { let mut parser = Qwen3CoderToolParser::new(&test_tools()); diff --git a/rust/src/tool-parser/src/utils.rs b/rust/src/tool-parser/src/utils.rs index 544c5d5dcb..b545c5881c 100644 --- a/rust/src/tool-parser/src/utils.rs +++ b/rust/src/tool-parser/src/utils.rs @@ -1,5 +1,6 @@ //! Shared helpers for tool parsers. +use winnow::Parser; use winnow::error::{ContextError, ErrMode, ModalResult, Needed, StrContext, StrContextValue}; use winnow::stream::{Offset, Partial, Stream}; @@ -66,6 +67,74 @@ pub(super) fn safe_text_len(input: &mut Partial<&str>, marker: &str) -> ModalRes Ok(emit_len) } +/// Streaming scan state for a buffered marker search [`take_until_marker`], +/// so that we don't have to rescan the whole buffered prefix when resuming. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub(super) struct MarkerScanState { + scan_start: usize, +} + +impl MarkerScanState { + pub(super) fn reset(&mut self) { + self.scan_start = 0; + } +} + +/// Parse text until `marker`, resuming from the last safe scan checkpoint. +/// +/// This is the streaming-buffered variant of `winnow::token::take_until(0.., +/// marker)`: it returns the slice before `marker` and leaves `marker` for the +/// caller to consume. On incomplete input, it stores the earliest byte offset +/// that can still match `marker` and returns `Incomplete` without consuming +/// input, so the next parse can avoid rescanning the whole buffered prefix. +/// +/// Use this for outer parser states that keep the full buffered input across +/// chunks while waiting for a closing marker. Plain `take_until` is still a +/// better fit for one-shot parsers over a complete body, and for `1..` cases +/// where an empty slice before the marker should be rejected. +pub(super) fn take_until_marker<'i, 'a>( + marker: &'a str, + state: &'a mut MarkerScanState, +) -> impl Parser, &'i str, ErrMode> + 'a { + move |input: &mut Partial<&'i str>| take_until_marker_(input, marker, state) +} + +fn take_until_marker_<'i>( + input: &mut Partial<&'i str>, + marker: &str, + state: &mut MarkerScanState, +) -> ModalResult<&'i str> { + debug_assert!(!marker.is_empty()); + + let text = **input; + if text.is_empty() { + return incomplete(); + } + + // Normal updates store a char boundary; this keeps stale or misused state from panicking. + let scan_start = floor_char_boundary(text, state.scan_start); + + if let Some(offset) = text[scan_start..].find(marker) { + let marker_start = scan_start + offset; + let body = &text[..marker_start]; + input.next_slice(marker_start); + state.reset(); + return Ok(body); + } + + let keep_len = partial_prefix_len(text, marker); + state.scan_start = text.len() - keep_len; + incomplete() +} + +fn floor_char_boundary(text: &str, index: usize) -> usize { + let mut index = index.min(text.len()); + while !text.is_char_boundary(index) { + index -= 1; + } + index +} + /// Streaming lexical state for a top-level JSON object. #[derive(Debug, Clone, Default, PartialEq, Eq)] pub(super) struct JsonObjectScanState { @@ -273,11 +342,13 @@ pub(super) fn incomplete() -> ModalResult { mod tests { use expect_test::expect; + use winnow::Parser; use winnow::error::ErrMode; use winnow::stream::{Offset, Partial, Stream}; use super::{ - JsonObjectScanState, json_str, partial_prefix_len, safe_text_len, take_json_object, + JsonObjectScanState, MarkerScanState, json_str, partial_prefix_len, safe_text_len, + take_json_object, take_until_marker, }; #[test] @@ -335,6 +406,103 @@ mod tests { assert!(matches!(error, ErrMode::Incomplete(_))); } + #[test] + fn take_until_marker_stops_before_marker() { + let mut state = MarkerScanState::default(); + let mut input = Partial::new("bodytail"); + let checkpoint = input.checkpoint(); + + let body = take_until_marker("", &mut state).parse_next(&mut input).unwrap(); + + assert_eq!(body, "body"); + assert_eq!(input.offset_from(&checkpoint), "body".len()); + assert_eq!(*input, "tail"); + assert_eq!(state, MarkerScanState::default()); + } + + #[test] + fn take_until_marker_resumes_after_split_marker() { + let mut state = MarkerScanState::default(); + let mut input = Partial::new("body", &mut state) + .parse_next(&mut input) + .unwrap_err(); + + assert!(matches!(error, ErrMode::Incomplete(_))); + assert_eq!(state.scan_start, "body".len()); + + let mut input = Partial::new("bodytail"); + let body = take_until_marker("", &mut state).parse_next(&mut input).unwrap(); + + assert_eq!(body, "body"); + assert_eq!(*input, "tail"); + assert_eq!(state, MarkerScanState::default()); + } + + #[test] + fn take_until_marker_advances_checkpoint_for_long_prefix() { + let mut state = MarkerScanState::default(); + let text = format!("{}{}", "x".repeat(1024), "", &mut state) + .parse_next(&mut input) + .unwrap_err(); + + assert!(matches!(error, ErrMode::Incomplete(_))); + assert_eq!(state.scan_start, 1024); + } + + #[test] + fn take_until_marker_keeps_unicode_marker_boundaries() { + let marker = "<|DSML|function_calls>"; + let mut state = MarkerScanState::default(); + let mut input = Partial::new("prefix <|DSML|fun"); + + let error = take_until_marker(marker, &mut state).parse_next(&mut input).unwrap_err(); + + assert!(matches!(error, ErrMode::Incomplete(_))); + assert_eq!(state.scan_start, "prefix ".len()); + assert!("prefix <|DSML|fun".is_char_boundary(state.scan_start)); + + let mut input = Partial::new("prefix <|DSML|function_calls>tail"); + let body = take_until_marker(marker, &mut state).parse_next(&mut input).unwrap(); + + assert_eq!(body, "prefix "); + assert_eq!(*input, "<|DSML|function_calls>tail"); + assert_eq!(state, MarkerScanState::default()); + } + + #[test] + fn take_until_marker_floors_stale_checkpoint_to_char_boundary() { + let mut state = MarkerScanState { scan_start: 1 }; + let mut input = Partial::new("é"); + + let body = take_until_marker("", &mut state).parse_next(&mut input).unwrap(); + + assert_eq!(body, "é"); + assert_eq!(*input, ""); + assert_eq!(state, MarkerScanState::default()); + } + + #[test] + fn take_until_marker_handles_overlapping_prefixes() { + let mut state = MarkerScanState::default(); + let mut input = Partial::new("xxaba"); + + let error = take_until_marker("ababa", &mut state).parse_next(&mut input).unwrap_err(); + + assert!(matches!(error, ErrMode::Incomplete(_))); + assert_eq!(state.scan_start, 2); + + let mut input = Partial::new("xxababa!"); + let body = take_until_marker("ababa", &mut state).parse_next(&mut input).unwrap(); + + assert_eq!(body, "xx"); + assert_eq!(*input, "ababa!"); + } + #[test] fn take_json_object_consumes_simple_object() { let mut state = JsonObjectScanState::default();