[Bugfix][Tool Parser] Migrate Granite to the streaming Parser Engine (#49648)

Signed-off-by: Nikhil Kulkarni <nikhilkulkarni1755@gmail.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
Co-authored-by: Chauncey <chaunceyjiang@gmail.com>
This commit is contained in:
Nikhil Kulkarni
2026-09-23 10:37:40 +00:00
committed by GitHub
co-authored by Claude Opus 4.8 Chauncey
parent c961121519
commit 15ed1262e7
14 changed files with 631 additions and 369 deletions
+102 -1
View File
@@ -190,6 +190,12 @@ class StreamingParserEngine:
self._args_in_string: bool = False
self._args_escape_next: bool = False
def _reset_array_state(self) -> None:
# State for ``tool_call_body_array``: whether the opening ``[`` has been
# seen, and whether a ``{...}`` element is currently being streamed.
self._array_started: bool = False
self._array_in_element: bool = False
def reset(self, initial_state: ParserState | None = None) -> None:
"""Reset mutable state for reuse across requests.
@@ -213,6 +219,7 @@ class StreamingParserEngine:
self._message_header_token_count = 0
self._in_skipped_tool_span = False
self._reset_args_state()
self._reset_array_state()
def feed(
self,
@@ -306,7 +313,12 @@ class StreamingParserEngine:
ParserState.TOOL_NAME,
ParserState.TOOL_BETWEEN,
):
if self.tool_index >= 0:
# In array mode a closed element has already emitted its
# TOOL_CALL_END; only a truncated (still-open) element needs one.
end_open_call = (
self._array_in_element if self.config.tool_call_body_array else True
)
if end_open_call and self.tool_index >= 0:
events.append(
SemanticEvent(
EventType.TOOL_CALL_END,
@@ -474,6 +486,8 @@ class StreamingParserEngine:
self._message_header_token_count += token_count
return []
if self.state == ParserState.TOOL_ARGS:
if self.config.tool_call_body_array:
return self._feed_array_text(text)
if self.config.tool_args_json:
return self._feed_args_text(text)
return [
@@ -564,6 +578,8 @@ class StreamingParserEngine:
self._args_in_string = False
self._args_escape_next = False
self._args_safe_end = 0
if self.config.tool_call_body_array:
self._reset_array_state()
return events
@@ -634,3 +650,88 @@ class StreamingParserEngine:
tool_index=self.tool_index,
)
]
# ── JSON-array tool body (tool_call_body_array) ─────────────────────
def _feed_array_text(self, text: str) -> list[SemanticEvent]:
"""Split a JSON-array tool body into one tool call per element.
Granite emits ``[{"name":..,"arguments":{..}}, ...]`` after the tool
marker. Element interiors are streamed through the string/brace-aware
:meth:`_feed_args_char`, so each element behaves exactly like a
single-object tool body; the array's ``]`` ends the region and any
trailing text becomes content.
"""
events: list[SemanticEvent] = []
for i, ch in enumerate(text):
if self.state != ParserState.TOOL_ARGS:
# The array closed mid-chunk; the rest of the text is content.
events.extend(self._emit_for_state(text[i:]))
break
events.extend(self._feed_array_char(ch))
return events
def _feed_array_char(self, ch: str) -> list[SemanticEvent]:
if self._array_in_element:
events = self._feed_args_char(ch)
# Element object closed: top-level '}' with all braces balanced.
if (
ch == "}"
and not self._args_in_string
and not self._args_escape_next
and self._args_brace_depth == 0
):
events.extend(self._end_array_element())
return events
# Between elements only structural array characters are expected.
if ch in " \t\r\n":
return []
if not self._array_started:
if ch == "[":
self._array_started = True
return []
return self._bail_array_to_content(ch)
if ch == ",":
return []
if ch == "{":
return self._start_array_element(ch)
if ch == "]":
self.state = ParserState.CONTENT
self._reset_array_state()
return []
return self._bail_array_to_content(ch)
def _start_array_element(self, ch: str) -> list[SemanticEvent]:
self.tool_index += 1
self._reset_args_state()
self._array_in_element = True
events = [SemanticEvent(EventType.TOOL_CALL_START, tool_index=self.tool_index)]
events.extend(self._feed_args_char(ch))
return events
def _end_array_element(self) -> list[SemanticEvent]:
self._array_in_element = False
events: list[SemanticEvent] = []
# Flush the held closing '}' so the slot body is the full element.
if self._args_buffer:
events.append(
SemanticEvent(
EventType.ARG_VALUE_CHUNK,
value=self._args_buffer,
tool_index=self.tool_index,
)
)
self._args_buffer = ""
self._args_safe_end = 0
events.append(
SemanticEvent(EventType.TOOL_CALL_END, tool_index=self.tool_index)
)
return events
def _bail_array_to_content(self, ch: str) -> list[SemanticEvent]:
# Marker not followed by a JSON array (malformed) — revert to content
# so the remaining tokens are emitted as plain text, no tool call.
self.state = ParserState.CONTENT
self._reset_array_state()
return self._emit_for_state(ch)