diff --git a/rust/src/chat/src/lib.rs b/rust/src/chat/src/lib.rs index 63b4cbdbf4..130d4c9f46 100644 --- a/rust/src/chat/src/lib.rs +++ b/rust/src/chat/src/lib.rs @@ -271,7 +271,7 @@ mod tests { ) .unwrap_err(); - expect_test::expect!["tool parser `definitely_missing_tool_parser` is not registered (choose from: deepseek_v3, deepseek_v31, deepseek_v32, deepseek_v4, gemma4, glm45, glm47, hermes, hy_v3, internlm, kimi_k2, llama3_json, llama4_json, minimax_m2, mistral, phi4_mini_json, qwen3_coder, qwen3_xml)"].assert_eq(&error.to_report_string()); + expect_test::expect!["tool parser `definitely_missing_tool_parser` is not registered (choose from: deepseek_v3, deepseek_v31, deepseek_v32, deepseek_v4, gemma4, glm45, glm47, granite4, hermes, hy_v3, internlm, kimi_k2, llama3_json, llama4_json, minimax_m2, mistral, phi4_mini_json, qwen3_coder, qwen3_xml)"].assert_eq(&error.to_report_string()); } #[test] diff --git a/rust/src/chat/src/parser/tool/mod.rs b/rust/src/chat/src/parser/tool/mod.rs index 29961d1d82..960d1d62af 100644 --- a/rust/src/chat/src/parser/tool/mod.rs +++ b/rust/src/chat/src/parser/tool/mod.rs @@ -4,10 +4,10 @@ use std::sync::LazyLock; pub use vllm_tool_parser::{ DeepSeekV3ToolParser, DeepSeekV4ToolParser, DeepSeekV31ToolParser, DeepSeekV32ToolParser, - Gemma4ToolParser, Glm45MoeToolParser, Glm47MoeToolParser, HermesToolParser, HyV3ToolParser, - Internlm2ToolParser, KimiK2ToolParser, Llama3JsonToolParser, MinimaxM2ToolParser, - MistralToolParser, Phi4MiniJsonToolParser, Qwen3CoderToolParser, Qwen3XmlToolParser, - ToolCallDelta, ToolParser, ToolParserError, ToolParserOutput, + Gemma4ToolParser, Glm45MoeToolParser, Glm47MoeToolParser, Granite4ToolParser, HermesToolParser, + HyV3ToolParser, Internlm2ToolParser, KimiK2ToolParser, Llama3JsonToolParser, + MinimaxM2ToolParser, MistralToolParser, Phi4MiniJsonToolParser, Qwen3CoderToolParser, + Qwen3XmlToolParser, ToolCallDelta, ToolParser, ToolParserError, ToolParserOutput, }; use crate::parser::ParserFactory; @@ -22,6 +22,7 @@ pub mod names { pub const GLM45: &str = "glm45"; pub const GLM47: &str = "glm47"; pub const GEMMA4: &str = "gemma4"; + pub const GRANITE4: &str = "granite4"; pub const HERMES: &str = "hermes"; pub const HY_V3: &str = "hy_v3"; // Matches the Python CLI name `--tool-call-parser internlm`, which Python @@ -64,6 +65,7 @@ impl ToolParserFactory { .register_parser::(names::GLM45) .register_parser::(names::GLM47) .register_parser::(names::GEMMA4) + .register_parser::(names::GRANITE4) .register_parser::(names::HERMES) .register_parser::(names::HY_V3) .register_parser::(names::INTERNLM) @@ -107,6 +109,7 @@ impl ToolParserFactory { .register_pattern("glm-4.5", names::GLM45) .register_pattern("gemma4", names::GEMMA4) .register_pattern("gemma-4", names::GEMMA4) + .register_pattern("granite-4", names::GRANITE4) .register_pattern("kimi-k2", names::KIMI_K2) .register_pattern("minimax", names::MINIMAX_M2) .register_pattern("mm-m2", names::MINIMAX_M2); diff --git a/rust/src/chat/src/parser/tool/tests.rs b/rust/src/chat/src/parser/tool/tests.rs index 6fd380bd22..5a2778157b 100644 --- a/rust/src/chat/src/parser/tool/tests.rs +++ b/rust/src/chat/src/parser/tool/tests.rs @@ -145,6 +145,10 @@ fn factory_new_resolves_default_patterns() { factory.resolve_name_for_model("google/gemma-4-27b-it"), Some(names::GEMMA4) ); + assert_eq!( + factory.resolve_name_for_model("ibm-granite/granite-4.0-h-tiny"), + Some(names::GRANITE4) + ); assert_eq!( factory.resolve_name_for_model("NousResearch/Hermes-3-Llama-3.1-8B"), Some(names::HERMES) diff --git a/rust/src/tool-parser/src/json/granite4.rs b/rust/src/tool-parser/src/json/granite4.rs new file mode 100644 index 0000000000..a70c064540 --- /dev/null +++ b/rust/src/tool-parser/src/json/granite4.rs @@ -0,0 +1,495 @@ +use winnow::ascii::multispace0 as ws0; +use winnow::combinator::{alt, peek, seq}; +use winnow::error::{ContextError, ErrMode, ModalResult, StrContext}; +use winnow::prelude::*; +use winnow::token::{any, literal}; + +use super::{ + JsonToolCallConfig, JsonToolCallEvent, JsonToolCallWhitespace, JsonToolInput, + tool_call_header_event, +}; +use crate::utils::{ + JsonObjectScanState, json_str, parse_buffered_event, safe_text_len, take_json_object, +}; +use crate::{Result, Tool, ToolCallDelta, ToolParser, ToolParserOutput}; + +const TOOL_CALL_START: &str = ""; +const TOOL_CALL_END: &str = ""; + +#[derive(Debug, Clone, PartialEq, Eq)] +enum Granite4Mode { + Text, + Header, + /// Parsing the arguments value: + /// `None` until the first byte decides object vs string; + /// `Some` while streaming an object value. + Args { + json_scan: Option, + }, + /// Arguments done; consume the object's closing `}` and ``. + Close, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +enum Granite4Event { + Text { + len: usize, + }, + ToolCallStart, + ToolCallHeader { + function_name: String, + }, + /// Verbatim bytes of an object-valued arguments payload; `complete` once the + /// object scan reaches its closing brace. + ObjectArgsDelta { + len: usize, + complete: bool, + }, + /// Decoded contents of a string-valued arguments payload. + StringArgs { + decoded: String, + }, + ToolCallEnd, +} + +/// Tool parser for Granite 4 `…` JSON tool calls. +/// +/// Example tool call content: +/// +/// ```text +/// {"name": "get_weather", "arguments": {"city": "Boston"}} +/// ``` +/// +/// Parallel calls are repeated `…` blocks with ordinary +/// content interleaved between them. This reuses the shared JSON helpers for +/// everything except one Granite 4 specific step (`args_event`): the `arguments` +/// value may be a JSON object (kept verbatim) **or** a JSON string whose decoded +/// contents are the arguments (the `# test granite behavior` case in Python). +pub struct Granite4ToolParser { + buffer: String, + mode: Granite4Mode, + active_tool_index: Option, + emitted_tool_count: usize, +} + +impl Granite4ToolParser { + /// Create a Granite 4 tool parser. + fn new(_tools: &[Tool]) -> Self { + Self { + buffer: String::new(), + mode: Granite4Mode::Text, + active_tool_index: None, + emitted_tool_count: 0, + } + } + + /// Apply one parsed Granite 4 event to parser state and output. + fn apply_event(&mut self, event: Granite4Event, output: &mut ToolParserOutput) -> Result<()> { + match event { + Granite4Event::Text { len } => output.normal_text.push_str(&self.buffer[..len]), + Granite4Event::ToolCallStart => self.mode = Granite4Mode::Header, + Granite4Event::ToolCallHeader { function_name } => { + let tool_index = self.emitted_tool_count; + self.emitted_tool_count += 1; + self.active_tool_index = Some(tool_index); + self.mode = Granite4Mode::Args { json_scan: None }; + output.calls.push(ToolCallDelta { + tool_index, + name: Some(function_name), + arguments: String::new(), + }); + } + Granite4Event::ObjectArgsDelta { len, complete } => { + let arguments = self.buffer[..len].to_string(); + self.push_arguments(arguments, output)?; + if complete { + self.mode = Granite4Mode::Close; + } + } + Granite4Event::StringArgs { decoded } => { + self.push_arguments(decoded, output)?; + self.mode = Granite4Mode::Close; + } + Granite4Event::ToolCallEnd => { + self.active_tool_index = None; + self.mode = Granite4Mode::Text; + } + } + Ok(()) + } + + /// Append one arguments delta to the active tool call. + fn push_arguments(&self, arguments: String, output: &mut ToolParserOutput) -> Result<()> { + let Some(tool_index) = self.active_tool_index else { + return Err(parsing_failed!( + "Granite4 arguments without an active tool call" + )); + }; + output.calls.push(ToolCallDelta { + tool_index, + name: None, + arguments, + }); + Ok(()) + } + + fn reset(&mut self) -> String { + self.mode = Granite4Mode::Text; + self.active_tool_index = None; + self.emitted_tool_count = 0; + std::mem::take(&mut self.buffer) + } +} + +impl ToolParser for Granite4ToolParser { + fn create(tools: &[Tool]) -> Result> + where + Self: Sized + 'static, + { + Ok(Box::new(Self::new(tools))) + } + + fn parse_into(&mut self, chunk: &str, output: &mut ToolParserOutput) -> Result<()> { + self.buffer.push_str(chunk); + + while let Some((event, consumed_len)) = parse_buffered_event(&self.buffer, |input| { + parse_next_granite4_event(input, &mut self.mode) + })? { + self.apply_event(event, output)?; + self.buffer.drain(..consumed_len); + } + + Ok(()) + } + + fn finish(&mut self) -> Result { + let mut output = ToolParserOutput::default(); + match &self.mode { + Granite4Mode::Text => output.normal_text.push_str(&self.buffer), + Granite4Mode::Header | Granite4Mode::Args { .. } | Granite4Mode::Close => { + return Err(parsing_failed!("incomplete Granite4 tool call")); + } + } + let _ = self.reset(); + Ok(output) + } + + fn reset(&mut self) -> String { + Granite4ToolParser::reset(self) + } +} + +/// Parse a Granite 4 event for the current parser mode. +fn parse_next_granite4_event( + input: &mut JsonToolInput<'_>, + mode: &mut Granite4Mode, +) -> ModalResult { + match mode { + Granite4Mode::Text => text_event(input), + Granite4Mode::Header => header_event(input), + Granite4Mode::Args { json_scan } => args_event(input, json_scan), + Granite4Mode::Close => close_event(input), + } +} + +/// Parse content text or the start of a `` block. *(reuses `safe_text_len`)* +fn text_event(input: &mut JsonToolInput<'_>) -> ModalResult { + alt(( + |input: &mut JsonToolInput<'_>| { + seq!(_: literal(TOOL_CALL_START), _: ws0) + .value(Granite4Event::ToolCallStart) + .parse_next(input) + }, + |input: &mut JsonToolInput<'_>| { + safe_text_len(input, TOOL_CALL_START).map(|len| Granite4Event::Text { len }) + }, + )) + .parse_next(input) +} + +/// Parse the `{"name":"X","arguments":` header before the value. *(reuses `tool_call_header_event`)* +fn header_event(input: &mut JsonToolInput<'_>) -> ModalResult { + const CONFIG: JsonToolCallConfig = JsonToolCallConfig { + parser_name: "Granite4", + start_marker: "", + end_marker: "", + marker_whitespace: JsonToolCallWhitespace::Optional, + delimiter: None, + name_key: "name", + arguments_key: &["arguments"], + }; + + match tool_call_header_event(input, CONFIG)? { + JsonToolCallEvent::ToolCallHeader { function_name } => { + Ok(Granite4Event::ToolCallHeader { function_name }) + } + _ => unreachable!("tool_call_header_event only emits ToolCallHeader"), + } +} + +/// Parse one arguments-value event. +/// +/// GRANITE 4 SPECIFIC - the sole behavior that differs from the shared +/// `` JSON parsers. The value is either a JSON object (kept verbatim, +/// streamed incrementally via `take_json_object`) or an escaped JSON string +/// (decoded whole via `json_str`). The string form is why we cannot just forward +/// raw arg bytes like the sibling parsers do: an escaped string only resolves +/// once seen whole and unescaped. +fn args_event( + input: &mut JsonToolInput<'_>, + json_scan: &mut Option, +) -> ModalResult { + if let Some(scan) = json_scan { + let len = take_json_object(input, scan)?; + return Ok(Granite4Event::ObjectArgsDelta { + len, + complete: scan.complete(), + }); + } + + match peek(any).parse_next(input)? { + '{' => { + let mut scan = JsonObjectScanState::default(); + let len = take_json_object(input, &mut scan)?; + let complete = scan.complete(); + *json_scan = Some(scan); + Ok(Granite4Event::ObjectArgsDelta { len, complete }) + } + '"' => Ok(Granite4Event::StringArgs { + decoded: json_str(input)?, + }), + _ => { + let mut error = ContextError::new(); + error.push(StrContext::Label("Granite4 arguments")); + Err(ErrMode::Cut(error)) + } + } +} + +/// Parse the tool-call object's closing `}` and the `` end marker. +fn close_event(input: &mut JsonToolInput<'_>) -> ModalResult { + seq!(_: ws0, _: literal("}"), _: ws0, _: literal(TOOL_CALL_END)) + .value(Granite4Event::ToolCallEnd) + .parse_next(input) +} + +#[cfg(test)] +mod tests { + use expect_test::expect; + use thiserror_ext::AsReport; + + use super::Granite4ToolParser; + use crate::test_utils::{collect_stream, split_by_chars, test_tools}; + use crate::{ToolParser, ToolParserOutput, ToolParserTestExt as _}; + + #[test] + fn granite4_parse_complete_without_tool_call_keeps_text() { + let mut parser = Granite4ToolParser::new(&test_tools()); + let output = parser.parse_complete("Hello, world!").unwrap(); + + assert_eq!(output.normal_text, "Hello, world!"); + assert!(output.calls.is_empty()); + } + + #[test] + fn granite4_parse_complete_object_args() { + let mut parser = Granite4ToolParser::new(&test_tools()); + let output = parser + .parse_complete( + r#"{"name":"get_weather","arguments":{"city":"Boston"}}"#, + ) + .unwrap(); + + assert_eq!(output.normal_text, ""); + assert_eq!(output.calls.len(), 1); + assert_eq!(output.calls[0].name.as_deref(), Some("get_weather")); + assert_eq!(output.calls[0].arguments, r#"{"city":"Boston"}"#); + } + + #[test] + fn granite4_parse_complete_string_args() { + // GRANITE4-SPECIFIC: `arguments` may be a pre-serialized JSON string; its + // decoded contents become the arguments. + let mut parser = Granite4ToolParser::new(&test_tools()); + let output = parser + .parse_complete( + r#"{"name":"get_weather","arguments":"{\"city\":\"Boston\"}"}"#, + ) + .unwrap(); + + assert_eq!(output.calls.len(), 1); + assert_eq!(output.calls[0].name.as_deref(), Some("get_weather")); + assert_eq!(output.calls[0].arguments, r#"{"city":"Boston"}"#); + } + + #[test] + fn granite4_extracts_interleaved_content_and_mixed_args() { + let mut parser = Granite4ToolParser::new(&test_tools()); + let output = parser + .parse_complete( + r#"before {"name":"find_bbox","arguments":"{\"x\":1}"} middle {"name":"get_weather","arguments":{"city":"Boston"}} after"#, + ) + .unwrap(); + + expect![[r#" + ToolParserOutput { + normal_text: "before middle after", + calls: [ + ToolCallDelta { + tool_index: 0, + name: Some( + "find_bbox", + ), + arguments: "{\"x\":1}", + }, + ToolCallDelta { + tool_index: 1, + name: Some( + "get_weather", + ), + arguments: "{\"city\":\"Boston\"}", + }, + ], + } + "#]] + .assert_debug_eq(&output); + } + + #[test] + fn granite4_streaming_handles_split_markers() { + let input = r#"hello {"name":"get_weather","arguments":{"city":"Tokyo"}} bye"#; + let chunks = split_by_chars(input, 5); + let mut parser = Granite4ToolParser::new(&test_tools()); + + let output = collect_stream(&mut parser, &chunks); + + assert_eq!(output.normal_text, "hello bye"); + assert_eq!(output.calls.len(), 1); + assert_eq!(output.calls[0].name.as_deref(), Some("get_weather")); + assert_eq!(output.calls[0].arguments, r#"{"city":"Tokyo"}"#); + } + + #[test] + fn granite4_streaming_emits_object_argument_deltas() { + let mut parser = Granite4ToolParser::new(&test_tools()); + let chunks = [ + r#"{"name":"get_weather","arguments":"#, + r#"{"city":"#, + r#""Beijing""#, + r#"}"#, + r#"}"#, + ]; + + let mut output = ToolParserOutput::default(); + let mut observed_arguments = Vec::new(); + for chunk in chunks { + let next = parser.parse_chunk(chunk).unwrap(); + observed_arguments.extend( + next.calls + .iter() + .filter(|call| call.name.is_none()) + .map(|call| call.arguments.clone()), + ); + output.append(next); + } + output.append(parser.finish().unwrap()); + + assert_eq!(observed_arguments, [r#"{"city":"#, r#""Beijing""#, r#"}"#]); + assert_eq!( + output.coalesce_calls().calls[0].arguments, + r#"{"city":"Beijing"}"# + ); + } + + #[test] + fn granite4_string_args_split_across_chunks() { + let input = r#"{"name":"f","arguments":"{\"a\":1}"}"#; + let chunks = split_by_chars(input, 3); + let mut parser = Granite4ToolParser::new(&test_tools()); + + let output = collect_stream(&mut parser, &chunks); + + assert_eq!(output.calls.len(), 1); + assert_eq!(output.calls[0].name.as_deref(), Some("f")); + assert_eq!(output.calls[0].arguments, r#"{"a":1}"#); + } + + #[test] + fn granite4_streaming_handles_marker_and_json_whitespace() { + // Granite spaces the markers (` {…} `) and the JSON + // (`"name": …`). Since `args_event` has no leading `ws0`, this guards that + // the header consumes the whitespace before the arguments value. + let input = concat!( + "Here goes the bbox call: \n", + r#" {"name": "find_bbox", "arguments": "{\"coordinates\": [[23.54, 43.1], [-12.2, 54.3], [4, 5]], \"coordinate_type\": \"latlong\"}"} "#, + " Now the stock price call: \n ", + r#" {"name": "get_stock_price", "arguments": {"symbol": "AAPL", "start_date": "2021-01-01", "end_date": "2021-12-31"}} "#, + " Now another bbox call: \n ", + r#" {"name": "find_bbox", "arguments": "{\"coordinates\": [[23.54, 43.1], [-12.2, 54.3], [4, 5]], \"coordinate_type\": \"latlong\"}"} "#, + " See? I'm a helpful assistant.", + ); + let chunks = split_by_chars(input, 3); + let mut parser = Granite4ToolParser::new(&test_tools()); + + let output = collect_stream(&mut parser, &chunks); + + expect![[r#" + ToolParserOutput { + normal_text: "Here goes the bbox call: \n Now the stock price call: \n Now another bbox call: \n See? I'm a helpful assistant.", + calls: [ + ToolCallDelta { + tool_index: 0, + name: Some( + "find_bbox", + ), + arguments: "{\"coordinates\": [[23.54, 43.1], [-12.2, 54.3], [4, 5]], \"coordinate_type\": \"latlong\"}", + }, + ToolCallDelta { + tool_index: 1, + name: Some( + "get_stock_price", + ), + arguments: "{\"symbol\": \"AAPL\", \"start_date\": \"2021-01-01\", \"end_date\": \"2021-12-31\"}", + }, + ToolCallDelta { + tool_index: 2, + name: Some( + "find_bbox", + ), + arguments: "{\"coordinates\": [[23.54, 43.1], [-12.2, 54.3], [4, 5]], \"coordinate_type\": \"latlong\"}", + }, + ], + } + "#]].assert_debug_eq(&output); + } + + #[test] + fn granite4_finish_fails_incomplete_tool_call() { + let mut parser = Granite4ToolParser::new(&test_tools()); + parser + .parse_chunk(r#"{"name":"get_weather","arguments":{"city""#) + .unwrap(); + + let error = parser.finish().unwrap_err(); + + expect!["tool parser parsing failed: incomplete Granite4 tool call"] + .assert_eq(&error.to_report_string()); + } + + #[test] + fn granite4_rejects_non_object_non_string_args() { + let mut parser = Granite4ToolParser::new(&test_tools()); + let error = parser + .parse_chunk(r#"{"name":"f","arguments":42}"#) + .unwrap_err(); + + expect!["tool parser parsing failed: invalid Granite4 arguments"] + .assert_eq(&error.to_report_string()); + } + + #[test] + fn granite4_preserve_special_tokens_is_false() { + let parser = Granite4ToolParser::new(&test_tools()); + assert!(!parser.preserve_special_tokens()); + } +} diff --git a/rust/src/tool-parser/src/json/mod.rs b/rust/src/tool-parser/src/json/mod.rs index 9cc1d2ed54..748f7e49e4 100644 --- a/rust/src/tool-parser/src/json/mod.rs +++ b/rust/src/tool-parser/src/json/mod.rs @@ -1,5 +1,6 @@ //! Shared parser core for JSON tool calls wrapped by text markers. +pub use granite4::Granite4ToolParser; pub use hermes::HermesToolParser; pub use internlm2::Internlm2ToolParser; pub use llama::Llama3JsonToolParser; @@ -7,6 +8,7 @@ pub use mistral::MistralToolParser; pub use phi4mini::Phi4MiniJsonToolParser; pub use qwen::Qwen3XmlToolParser; +mod granite4; mod hermes; mod internlm2; mod llama; diff --git a/rust/src/tool-parser/src/lib.rs b/rust/src/tool-parser/src/lib.rs index 6e77af7bcf..f611cbb7d1 100644 --- a/rust/src/tool-parser/src/lib.rs +++ b/rust/src/tool-parser/src/lib.rs @@ -25,8 +25,8 @@ pub use gemma4::Gemma4ToolParser; pub use glm_xml::{Glm45MoeToolParser, Glm47MoeToolParser}; pub use hy_v3::HyV3ToolParser; pub use json::{ - HermesToolParser, Internlm2ToolParser, Llama3JsonToolParser, MistralToolParser, - Phi4MiniJsonToolParser, Qwen3XmlToolParser, + Granite4ToolParser, HermesToolParser, Internlm2ToolParser, Llama3JsonToolParser, + MistralToolParser, Phi4MiniJsonToolParser, Qwen3XmlToolParser, }; pub use kimi_k2::KimiK2ToolParser; pub use minimax_m2::MinimaxM2ToolParser;