"tests/TestMonteCarloAnisotropicBarostat.h" did not exist on "62c4fd533a119565bc290acd4ae7c2d9e57a2b2a"
qwen3xml_tool_parser.py 52.5 KB
Newer Older
1
2
3
4
5
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import ast
import json
from collections.abc import Sequence
6
from typing import Any
7
8
9
10
from xml.parsers.expat import ParserCreate

import regex as re

11
from vllm.entrypoints.chat_utils import make_tool_call_id
12
13
14
15
16
17
18
19
20
21
from vllm.entrypoints.openai.protocol import (
    ChatCompletionRequest,
    ChatCompletionToolsParam,
    DeltaFunctionCall,
    DeltaMessage,
    DeltaToolCall,
    ExtractedToolCallInformation,
    FunctionCall,
    ToolCall,
)
22
from vllm.logger import init_logger
23
from vllm.tokenizers import TokenizerLike
24
25
26
from vllm.tool_parsers.abstract_tool_parser import (
    ToolParser,
)
27
28
29
30
31
32
33
34
35
36
37
38
39
40

logger = init_logger(__name__)


class StreamingXMLToolCallParser:
    """
    Simplified streaming XML tool call parser
    Supports streaming input, parsing, and output
    """

    def __init__(self):
        self.reset_streaming_state()

        # Tool configuration information
41
        self.tools: list[ChatCompletionToolsParam] | None = None
42
43
44
45
46
47
        self.tool_call_start_token: str = "<tool_call>"
        self.tool_call_end_token: str = "</tool_call>"
        self.function_start_token: str = "<function="
        self.function_end_token: str = "</function>"
        self.parameter_start_token: str = "<parameter="
        self.parameter_end_token: str = "</parameter>"
48
49
50
51
52
53
54
55
56
57
58
59
60

    def reset_streaming_state(self):
        """Reset streaming parsing state"""

        self.deltas = []
        # state for streaming
        self.tool_call_index = 0
        self.current_call_id = None
        self.last_completed_call_id = None
        self.current_function_name = None
        self.current_function_open = False
        self.parameters = {}
        self.current_param_name = None
61
62
        self.current_param_value = ""
        self.current_param_value_converted = ""
63
64
65
66
        self.current_param_is_first = False
        self.should_emit_end_newline = False
        self.start_quote_emitted = False

67
        self.streaming_buffer = ""
68
69
        self.last_processed_pos = 0

70
        self.text_content_buffer = ""
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

        # state for preprocessing and deferred parsing
        self._pre_inside_parameter = False
        self._pre_param_buffer = ""
        self._pre_current_param_name = None
        self.defer_current_parameter = False
        self.deferred_param_raw_value = ""

        # recreate parser
        self.parser = ParserCreate()
        self.setup_parser()

    def parse_single_streaming_chunks(self, xml_chunk: str) -> DeltaMessage:
        """
        Parse single streaming XML chunk and return Delta response
86
        This is the actual streaming interface that receives chunks
87
88
89
90
91
        one by one and maintains internal state

        Args:
            xml_chunk: Single XML chunk string
        Returns:
92
            DeltaMessage: Contains delta information generated by this chunk,
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
            returns empty response if no complete elements
        """
        # Record delta count before processing
        initial_delta_count = len(self.deltas)

        self.streaming_buffer += xml_chunk

        found_elements = self._process_complete_xml_elements()

        if found_elements:
            # If complete elements found, check if end events were missed
            # some tags may not have been triggered
            try:
                new_deltas = self.deltas[initial_delta_count:]
                # If this chunk contains </function>
                # but didn't generate '}', then complete it
109
110
111
112
                if (
                    self.current_call_id is not None
                    and self.function_end_token in xml_chunk
                ):
113
114
                    # - Added '}' (non-empty parameter ending)
                    # - Added '{}' (empty parameter function)
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
                    has_function_close = any(
                        (
                            td.tool_calls
                            and any(
                                (
                                    tc.function
                                    and tc.id == self.current_call_id
                                    and isinstance(tc.function.arguments, str)
                                    and (tc.function.arguments in ("}", "{}"))
                                )
                                for tc in td.tool_calls
                            )
                        )
                        for td in new_deltas
                    )
130
131
132
                    if not has_function_close:
                        # Close potentially unclosed element
                        if self.current_param_name:
133
                            self._end_element("parameter")
134
                        if self.current_function_name:
135
                            self._end_element("function")
136
137
                # If this chunk contains </tool_call>
                # but didn't generate final empty delta, then complete it
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
                if (
                    self.current_call_id is not None
                    and self.tool_call_end_token in xml_chunk
                ):
                    has_toolcall_close = any(
                        (
                            td.tool_calls
                            and any(
                                (
                                    tc.type == "function"
                                    and tc.function
                                    and tc.function.arguments == ""
                                    and tc.id == self.current_call_id
                                )
                                for tc in td.tool_calls
                            )
                        )
                        for td in new_deltas
                    )
157
158
159
                    if not has_toolcall_close:
                        # Close potentially unclosed element
                        if self.current_param_name:
160
                            self._end_element("parameter")
161
                        if self.current_function_name:
162
163
                            self._end_element("function")
                        self._end_element("tool_call")
164
165
166
167
            except Exception as e:
                logger.warning("Error with fallback parsing: %s", e)
            # Merge newly generated deltas into single response
            result_delta = self._merge_new_deltas_to_single_response(
168
169
                initial_delta_count
            )
170
171
172
173
174
175
176
177
            return result_delta
        else:
            # No complete elements, check if there's unoutput text content
            if self.text_content_buffer and self.tool_call_index == 0:
                # Has text content but no tool_call yet, output text content
                text_delta = DeltaMessage(content=self.text_content_buffer)
                self._emit_delta(text_delta)
                # Clear buffer to avoid duplicate output
178
                self.text_content_buffer = ""
179
180
181
182
183
184
185
                return text_delta

            # If this chunk contains end tags but wasn't triggered by parser,
            # manually complete end events
            # Only execute when still on the same call as when entered,
            # to prevent accidentally closing new calls
            # in multi <tool_call> scenarios
186
187
188
189
            if self.current_call_id is not None and (
                self.function_end_token in xml_chunk
                or self.tool_call_end_token in xml_chunk
            ):
190
191
                # Close potentially unclosed element
                if self.current_param_name:
192
193
194
                    self._end_element("parameter")
                if self.function_end_token in xml_chunk and self.current_function_name:
                    self._end_element("function")
195
                if self.tool_call_end_token in xml_chunk:
196
                    self._end_element("tool_call")
197
198
                # Return the merged delta result generated by this fallback
                result_delta = self._merge_new_deltas_to_single_response(
199
200
                    initial_delta_count
                )
201
202
203
204
205
206
207
208
209
210
211
212
213
214
                return result_delta

            # No complete elements, return empty response
            return DeltaMessage(content=None)

    def _escape_xml_special_chars(self, text: str) -> str:
        """
        Escape XML special characters
        Args:
            text: Original text
        Returns:
            Escaped text
        """
        xml_escapes = {
215
216
217
218
219
            "&": "&amp;",
            "<": "&lt;",
            ">": "&gt;",
            '"': "&quot;",
            "'": "&apos;",
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
        }

        for char, escape in xml_escapes.items():
            text = text.replace(char, escape)

        return text

    def _process_complete_xml_elements(self) -> bool:
        """
        Process complete XML elements in buffer

        Returns:
            bool: Whether complete elements were found and processed
        """
        found_any = False

        while self.last_processed_pos < len(self.streaming_buffer):
            # Find next complete xml element
238
            element, end_pos = self._find_next_complete_element(self.last_processed_pos)
239
240
241
242
243
244
245
246
247
248
249
250
251
            if element is None:
                # No complete element found, wait for more data
                break

            # Check if this element should be skipped
            if self._should_skip_element(element):
                self.last_processed_pos = end_pos
                continue

            # Found complete XML element, process it
            try:
                preprocessed_element = self._preprocess_xml_chunk(element)
                # Check if this is the first tool_call start
252
253
254
255
256
257
258
                if (
                    (
                        preprocessed_element.strip().startswith("<tool_call>")
                        or preprocessed_element.strip().startswith("<function name=")
                    )
                    and self.tool_call_index == 0
                ) and self.text_content_buffer:
259
260
261
262
263
                    # First tool_call starts,
                    # output previously collected text content first
                    text_delta = DeltaMessage(content=self.text_content_buffer)
                    self._emit_delta(text_delta)
                    # Clear buffer for potential subsequent text content
264
                    self.text_content_buffer = ""
265
266
267

                # If a new tool_call starts and
                # there are already completed tool_calls
268
269
270
271
272
                if (
                    preprocessed_element.strip().startswith("<tool_call>")
                    and self.tool_call_index > 0
                    and self.current_call_id
                ):
273
274
                    # Reset parser state but preserve generated deltas
                    if self.current_param_name:
275
                        self._end_element("parameter")
276
                    if self.current_function_open or self.current_function_name:
277
                        self._end_element("function")
278
279
280
281
                    # Output final tool_call tail delta
                    final_delta = DeltaMessage(
                        role=None,
                        content=None,
282
                        reasoning=None,
283
                        tool_calls=[
284
285
286
287
288
289
290
291
                            DeltaToolCall(
                                index=self.tool_call_index - 1,
                                id=self.current_call_id,
                                type="function",
                                function=DeltaFunctionCall(name=None, arguments=""),
                            )
                        ],
                    )
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
                    self._emit_delta(final_delta)
                    # Reset XML parser and current call state
                    self._reset_xml_parser_after_tool_call()
                # Parse preprocessed element
                self.parser.Parse(preprocessed_element, False)
                found_any = True

            except Exception as e:
                logger.warning("Error when parsing XML elements: %s", e)

            # Update processed position
            self.last_processed_pos = end_pos

        return found_any

    def _should_skip_element(self, element: str) -> bool:
        """
        Determine whether an element should be skipped

        Args:
            element: Element to evaluate

        Returns:
            bool: True means should skip, False means should process
        """

        # If it's a tool_call XML tag, don't skip
319
320
321
322
323
        if (
            element.startswith(self.tool_call_start_token)
            or element.startswith(self.function_start_token)
            or element.startswith(self.parameter_start_token)
        ):
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
            return False

        # If currently not parsing tool calls and not blank,
        # collect this text instead of skipping
        # Only process other XML elements after tool_call appears,
        # otherwise treat as plain text
        if self.current_call_id is None and element:
            # Collect text content to buffer
            self.text_content_buffer += element
            return True  # Still skip, but content has been collected

        # If currently parsing tool calls,
        # this might be parameter value, don't skip
        if self.current_call_id is not None:
            return False

        # Skip blank content
        return not element

343
    def _find_next_complete_element(self, start_pos: int) -> tuple[str | None, int]:
344
345
346
347
348
349
350
        """
        Find next complete XML element from specified position

        Args:
            start_pos: Position to start searching

        Returns:
351
            (Complete element string, element end position),
352
353
354
355
356
357
358
            returns (None, start_pos) if no complete element found
        """
        buffer = self.streaming_buffer[start_pos:]

        if not buffer:
            return None, start_pos

359
        if buffer.startswith("<"):
360
361
            # Need to ensure no new < appears,
            # find the nearest one between < and >
362
363
            tag_end = buffer.find("<", 1)
            tag_end2 = buffer.find(">", 1)
364
365
366
367
368
369
            if tag_end != -1 and tag_end2 != -1:
                # Next nearest is <
                if tag_end < tag_end2:
                    return buffer[:tag_end], start_pos + tag_end
                # Next nearest is >, means found XML element
                else:
370
                    return buffer[: tag_end2 + 1], start_pos + tag_end2 + 1
371
372
373
            elif tag_end != -1:
                return buffer[:tag_end], start_pos + tag_end
            elif tag_end2 != -1:
374
                return buffer[: tag_end2 + 1], start_pos + tag_end2 + 1
375
376
            else:
                # If currently not parsing tool calls (entering a tool_call),
377
                # check if starts with <tool_call> or <function=
378
379
                if self.current_call_id is None:
                    # Check if might be start of <tool_call>
380
                    if buffer == "<tool_call>"[: len(buffer)]:
381
382
                        # Might be start of <tool_call>, wait for more data
                        return None, start_pos
383
384
385
386
387
388
389
                    elif (
                        buffer.startswith("<function=")
                        or buffer == "<function="[: len(buffer)]
                    ):
                        # Might be start of <function=, wait for more data
                        # to get the complete function tag
                        return None, start_pos
390
                    else:
391
                        # Not start of <tool_call> or <function=, treat as text
392
393
394
395
396
397
398
                        return buffer, start_pos + len(buffer)
                else:
                    # When parsing tool calls,
                    # wait for more data to get complete tag
                    return None, start_pos
        else:
            # Find text content (until next < or buffer end)
399
            next_tag_pos = buffer.find("<")
400
401
402
403
404
405
406
407
408
409
            if next_tag_pos != -1:
                # Found text content
                text_content = buffer[:next_tag_pos]
                return text_content, start_pos + next_tag_pos
            else:
                # Buffer end is all text, process
                # (no longer wait for more data)
                remaining = buffer
                return remaining, start_pos + len(remaining)

410
    def _merge_new_deltas_to_single_response(self, initial_count: int) -> DeltaMessage:
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
        """
        Merge newly generated deltas from this processing
        into a single DeltaMessage

        Args:
            initial_count: Delta count before processing

        Returns:
            Merged DeltaMessage containing all newly generated delta information
        """
        if len(self.deltas) <= initial_count:
            return DeltaMessage(content=None)

        # Get newly generated deltas
        new_deltas = self.deltas[initial_count:]

        if len(new_deltas) == 1:
            # Only one new delta, return directly
            return new_deltas[0]

        # Merge multiple new deltas
        merged_tool_calls: list[DeltaToolCall] = []
433
        merged_content: str = ""
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450

        for delta in new_deltas:
            if delta.content:
                merged_content += delta.content
            if delta.tool_calls:
                # For tool_calls, we need to intelligently merge arguments
                for tool_call in delta.tool_calls:
                    # Find if there's already a tool_call with the same call_id
                    existing_call = None
                    for existing in merged_tool_calls:
                        if existing.id == tool_call.id:
                            existing_call = existing
                            break

                    if existing_call and existing_call.function:
                        # Merge to existing tool_call
                        if tool_call.function and tool_call.function.name:
451
452
453
454
455
                            existing_call.function.name = tool_call.function.name
                        if (
                            tool_call.function
                            and tool_call.function.arguments is not None
                        ):
456
                            if existing_call.function.arguments is None:
457
                                existing_call.function.arguments = ""
458
459
460
461
462
463
464
465
466
467
468

                            # For streaming JSON parameters,
                            # simply concatenate in order
                            new_args = tool_call.function.arguments
                            existing_call.function.arguments += new_args
                        if tool_call.type:
                            existing_call.type = tool_call.type
                    else:
                        # Add new tool_call
                        merged_tool_calls.append(tool_call)

469
470
471
472
        return DeltaMessage(
            content=merged_content if merged_content else None,
            tool_calls=merged_tool_calls,
        )
473
474
475

    def _preprocess_xml_chunk(self, chunk: str) -> str:
        """
476
        Preprocess XML chunk, handle non-standard formats,
477
478
479
480
481
482
483
484
485
486
487
488
        and escape special characters

        Args:
            chunk: Original XML chunk

        Returns:
            Processed XML chunk
        """

        # Check if this is a tool_call related element
        is_tool_call = False
        if chunk.startswith(self.tool_call_start_token) or chunk.startswith(
489
490
            self.tool_call_end_token
        ):
491
492
            is_tool_call = True
        if chunk.startswith(self.function_start_token) or chunk.startswith(
493
494
            self.function_end_token
        ):
495
496
            is_tool_call = True
        if chunk.startswith(self.parameter_start_token) or chunk.startswith(
497
498
            self.parameter_end_token
        ):
499
500
            is_tool_call = True
        # Handle <function=name> format -> <function name="name">
501
        processed = re.sub(r"<function=([^>]+)>", r'<function name="\1">', chunk)
502
        # Handle <parameter=name> format -> <parameter name="name">
503
        processed = re.sub(r"<parameter=([^>]+)>", r'<parameter name="\1">', processed)
504
505
506
507
508
509

        original_chunk = chunk
        # If in parameter value accumulation mode
        if self._pre_inside_parameter:
            # Parameter end: output accumulated raw text
            # safely then return </parameter>
510
            if processed.startswith("</parameter>"):
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
                body_text = self._pre_param_buffer
                # Trigger deferred parsing mode
                # literal_eval+json output in end_element
                self.defer_current_parameter = True
                self.deferred_param_raw_value = body_text
                # Clean up state
                self._pre_inside_parameter = False
                self._pre_param_buffer = ""
                self._pre_current_param_name = None
                safe_text = self._escape_xml_special_chars(body_text)
                return f"{safe_text}</parameter>"
            else:
                # If this is the first block of content after entering parameter
                # evaluate if deferred parsing is needed;
                # If not needed, exit accumulation mode
                # and pass through directly
                if self._pre_param_buffer == "":
                    # Get current parameter type
529
530
531
532
533
                    param_type = (
                        self._get_param_type(self._pre_current_param_name)
                        if self._pre_current_param_name
                        else "string"
                    )
534
535
536
                    # Only these types need deferred parsing to
                    # handle Python literals containing single quotes
                    is_object_type = param_type in ["object"]
537
538
539
540
541
                    is_complex_type = (
                        param_type in ["array", "arr", "sequence"]
                        or param_type.startswith("dict")
                        or param_type.startswith("list")
                    )
542
543
544

                    # Only delay when contains container symbols
                    # and has single quotes and is complex type
545
546
547
548
549
                    has_container_hint = (
                        ("[" in original_chunk)
                        or ("{" in original_chunk)
                        or ("(" in original_chunk)
                    )
550
551
552
553
554
555

                    # Determine if deferred parsing is needed
                    need_defer = False
                    if is_complex_type:
                        # Complex type, always need deferred parsing
                        need_defer = True
556
557
558
559
560
                    elif (
                        is_object_type
                        and has_container_hint
                        and ("'" in original_chunk)
                    ):
561
562
563
564
565
566
567
568
569
570
571
572
573
                        # Object type with container symbols
                        # and single quotes, need deferred parsing
                        need_defer = True

                    if not need_defer:
                        # No need for deferred parsing,
                        # exit parameter mode directly
                        self._pre_inside_parameter = False
                        return self._escape_xml_special_chars(original_chunk)
                self._pre_param_buffer += original_chunk
                return ""

        # Parameter start: enable accumulation
574
        if processed.startswith("<parameter name="):
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
            m = re.match(r'<parameter name="([^"]+)">', processed)
            if m:
                self._pre_current_param_name = m.group(1)
            self._pre_inside_parameter = True
            self._pre_param_buffer = ""
            return processed

        # If processed doesn't contain special_token, escape processed
        # This is because XML parsing encounters special characters
        # and reports errors, so escaping is needed
        if not is_tool_call:
            processed = self._escape_xml_special_chars(processed)
        return processed

    def _emit_delta(self, delta: DeltaMessage):
        """Emit Delta response (streaming output)"""
        self.deltas.append(delta)

593
    def _auto_close_open_parameter_if_needed(self, incoming_tag: str | None = None):
594
595
        """Before starting to process new elements,
        if there are unclosed tags from before,
596
        automatically complete their endings to the parser.
597
        - If there are unclosed parameters,
598
        it's equivalent to feeding `</parameter>`
599
        - When about to start a new function or tool_call,
600
        if there are unclosed functions, complete `</function>`.
601
        - When about to start a new tool_call,
602
603
604
605
        if there are unclosed tool_calls, complete `</tool_call>`.
        """
        # First close unclosed parameters
        if self.current_param_name:
606
            self._end_element("parameter")
607
608
609

        # If about to start new function or tool_call,
        # and there are unclosed functions, close function first
610
611
        if incoming_tag in ("function", "tool_call") and self.current_function_name:
            self._end_element("function")
612
613
614

        # If about to start new tool_call,
        # and there are unclosed tool_calls, close tool_call first
615
616
        if incoming_tag == "tool_call" and self.current_call_id:
            self._end_element("tool_call")
617
618
619
620

    def _start_element(self, name: str, attrs: dict[str, str]):
        """Handle XML start element events"""

621
        if name == "root":
622
623
            return

624
        if name == "tool_call":
625
626
            # Before opening new tool_call,
            # automatically complete previous unclosed tags
627
            self._auto_close_open_parameter_if_needed("tool_call")
628
629

            self.parameters = {}
630
            self.current_call_id = make_tool_call_id()
631
632
            self.current_param_is_first = True
            self.tool_call_index += 1
633
        elif name.startswith("function") or (name == "function"):
634
635
            # If missing tool_call, manually complete
            if not self.current_call_id:
636
                self._start_element("tool_call", {})
637
638
            # Before opening new function,
            # automatically complete previous unclosed tags (parameter/function)
639
            self._auto_close_open_parameter_if_needed("function")
640
641
642
643
            function_name = self._extract_function_name(name, attrs)
            self.current_function_name = function_name
            self.current_function_open = True
            if function_name:
644
645
646
647
648
649
650
651
652
653
654
655
                delta = DeltaMessage(
                    tool_calls=[
                        DeltaToolCall(
                            index=self.tool_call_index - 1,
                            id=self.current_call_id,
                            type="function",
                            function=DeltaFunctionCall(
                                name=function_name, arguments=""
                            ),
                        )
                    ]
                )
656
                self._emit_delta(delta)
657
        elif name.startswith("parameter") or (name == "parameter"):
658
659
            # If previous parameter hasn't ended normally,
            # complete its end first, then start new parameter
660
            self._auto_close_open_parameter_if_needed("parameter")
661
662
            param_name = self._extract_parameter_name(name, attrs)
            self.current_param_name = param_name
663
664
            self.current_param_value = ""
            self.current_param_value_converted = ""
665
666
667
668
669
670
671
672
673
674
            self.start_quote_emitted = False  # Reset start quote flag

            # Only output parameter name and colon,
            # don't output quotes
            # decide after parameter value type is determined
            if param_name:
                if not self.parameters:
                    # First parameter
                    # start JSON, only output parameter name and colon
                    json_start = f'{{"{param_name}": '
675
676
677
678
679
680
681
682
683
684
685
686
                    delta = DeltaMessage(
                        tool_calls=[
                            DeltaToolCall(
                                index=self.tool_call_index - 1,
                                id=self.current_call_id,
                                type="function",
                                function=DeltaFunctionCall(
                                    name=None, arguments=json_start
                                ),
                            )
                        ]
                    )
687
688
689
690
691
692
                    self._emit_delta(delta)
                    self.current_param_is_first = True
                else:
                    # Subsequent parameters
                    # add comma and parameter name, no quotes
                    json_continue = f', "{param_name}": '
693
694
695
696
697
698
699
700
701
702
703
704
                    delta = DeltaMessage(
                        tool_calls=[
                            DeltaToolCall(
                                index=self.tool_call_index - 1,
                                id=self.current_call_id,
                                type="function",
                                function=DeltaFunctionCall(
                                    name=None, arguments=json_continue
                                ),
                            )
                        ]
                    )
705
706
707
708
709
710
711
712
713
714
715
                    self._emit_delta(delta)
                    self.current_param_is_first = False

    def _char_data(self, data: str):
        """Handle XML character data events"""
        if data and self.current_param_name:
            # If preprocessing stage determines deferred parsing is needed,
            # only cache character data, no streaming output
            if self.defer_current_parameter:
                original_data = data
                if self.should_emit_end_newline:
716
                    original_data = "\n" + original_data
717
                    self.should_emit_end_newline = False
718
                if original_data.endswith("\n"):
719
720
721
722
723
724
725
726
727
                    self.should_emit_end_newline = True
                    original_data = original_data[:-1]
                self.current_param_value += original_data
                return

            param_type = self._get_param_type(self.current_param_name)

            # Check if this is the first time receiving data for this parameter
            # If this is the first packet of data and starts with \n, remove \n
728
            if not self.current_param_value and data.startswith("\n"):
729
730
731
                data = data[1:]

            # Output start quote for string type (if not already output)
732
733
734
735
736
737
738
739
740
741
742
743
744
745
            if (
                param_type in ["string", "str", "text", "varchar", "char", "enum"]
                and not self.start_quote_emitted
            ):
                quote_delta = DeltaMessage(
                    tool_calls=[
                        DeltaToolCall(
                            index=self.tool_call_index - 1,
                            id=self.current_call_id,
                            type="function",
                            function=DeltaFunctionCall(name=None, arguments='"'),
                        )
                    ]
                )
746
747
748
749
750
751
752
753
754
                self._emit_delta(quote_delta)
                self.start_quote_emitted = True

            if not data:
                return

            original_data = data
            # Delay output of trailing newline
            if self.should_emit_end_newline:
755
                original_data = "\n" + original_data
756
                self.should_emit_end_newline = False
757
            if original_data.endswith("\n"):
758
759
760
761
762
763
                self.should_emit_end_newline = True
                original_data = original_data[:-1]
            self.current_param_value += original_data

            # convert parameter value by param_type
            converted_value = self._convert_param_value(
764
765
766
                self.current_param_value, param_type
            )
            output_data = self._convert_for_json_streaming(converted_value, param_type)
767

768
            delta_data = output_data[len(self.current_param_value_converted) :]
769
770
            self.current_param_value_converted = output_data

771
772
773
774
775
776
777
778
779
780
            delta = DeltaMessage(
                tool_calls=[
                    DeltaToolCall(
                        index=self.tool_call_index - 1,
                        id=self.current_call_id,
                        type="function",
                        function=DeltaFunctionCall(name=None, arguments=delta_data),
                    )
                ]
            )
781
782
783
784
785
            self._emit_delta(delta)

    def _end_element(self, name: str):
        """Handle XML end element events"""

786
        if name == "root":
787
788
789
790
            return

        # If function or tool_call ends and there are still unclosed parameters,
        # complete parameter end first
791
792
793
        if (
            name.startswith("function") or name == "function" or name == "tool_call"
        ) and self.current_param_name:
794
795
            self._auto_close_open_parameter_if_needed()

796
797
798
        if (
            name.startswith("parameter") or name == "parameter"
        ) and self.current_param_name:
799
800
801
802
803
804
805
806
            # End current parameter
            param_name = self.current_param_name
            param_value = self.current_param_value

            # If in deferred parsing mode,
            # perform overall parsing on raw content
            # accumulated in preprocessing stage and output once
            if self.defer_current_parameter:
807
808
809
810
811
                raw_text = (
                    self.deferred_param_raw_value
                    if self.deferred_param_raw_value
                    else param_value
                )
812
813
814
815
816
817
                parsed_value = None
                output_arguments = None
                try:
                    # If previously delayed trailing newline,
                    # add it back before parsing
                    if self.should_emit_end_newline:
818
                        raw_for_parse = raw_text + "\n"
819
820
821
                    else:
                        raw_for_parse = raw_text
                    parsed_value = ast.literal_eval(raw_for_parse)
822
                    output_arguments = json.dumps(parsed_value, ensure_ascii=False)
823
824
825
826
827
                except Exception:
                    # Fallback: output as string as-is
                    output_arguments = json.dumps(raw_text, ensure_ascii=False)
                    parsed_value = raw_text

828
829
830
831
832
833
834
835
836
837
838
839
                delta = DeltaMessage(
                    tool_calls=[
                        DeltaToolCall(
                            index=self.tool_call_index - 1,
                            id=self.current_call_id,
                            type="function",
                            function=DeltaFunctionCall(
                                name=None, arguments=output_arguments
                            ),
                        )
                    ]
                )
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
                self._emit_delta(delta)

                # Clean up and store
                self.should_emit_end_newline = False
                self.parameters[param_name] = parsed_value
                self.current_param_name = None
                self.current_param_value = ""
                self.current_param_value_converted = ""
                self.start_quote_emitted = False
                self.defer_current_parameter = False
                self.deferred_param_raw_value = ""
                return

            param_type = self._get_param_type(param_name)

            # convert complete parameter value by param_type
856
            converted_value = self._convert_param_value(param_value, param_type)
857
858

            # Decide whether to add end quote based on parameter type
859
            if param_type in ["string", "str", "text", "varchar", "char", "enum"]:
860
861
862
863
                # For empty string parameters, need special handling
                if not param_value and not self.start_quote_emitted:
                    # No start quote output,
                    # directly output complete empty string
864
865
866
867
868
869
870
871
872
873
                    delta = DeltaMessage(
                        tool_calls=[
                            DeltaToolCall(
                                index=self.tool_call_index - 1,
                                id=self.current_call_id,
                                type="function",
                                function=DeltaFunctionCall(name=None, arguments='""'),
                            )
                        ]
                    )
874
875
876
                    self._emit_delta(delta)
                else:
                    # Non-empty parameter value, output end quote
877
878
879
880
881
882
883
884
885
886
                    delta = DeltaMessage(
                        tool_calls=[
                            DeltaToolCall(
                                index=self.tool_call_index - 1,
                                id=self.current_call_id,
                                type="function",
                                function=DeltaFunctionCall(name=None, arguments='"'),
                            )
                        ]
                    )
887
888
889
890
891
892
                    self._emit_delta(delta)

            self.should_emit_end_newline = False
            # Store converted value
            self.parameters[param_name] = converted_value
            self.current_param_name = None
893
894
            self.current_param_value = ""
            self.current_param_value_converted = ""
895
896
            self.start_quote_emitted = False

897
        elif name.startswith("function") or name == "function":
898
899
            # if there are parameters, close JSON object
            if self.parameters:
900
901
902
903
904
905
906
907
908
909
                delta = DeltaMessage(
                    tool_calls=[
                        DeltaToolCall(
                            index=self.tool_call_index - 1,
                            id=self.current_call_id,
                            type="function",
                            function=DeltaFunctionCall(name=None, arguments="}"),
                        )
                    ]
                )
910
911
912
                self._emit_delta(delta)
            # return empty object
            else:
913
914
915
916
917
918
919
920
921
922
                delta = DeltaMessage(
                    tool_calls=[
                        DeltaToolCall(
                            index=self.tool_call_index - 1,
                            id=self.current_call_id,
                            type="function",
                            function=DeltaFunctionCall(name=None, arguments="{}"),
                        )
                    ]
                )
923
924
925
                self._emit_delta(delta)
            self.current_function_open = False

926
        elif name == "tool_call":
927
928
929
930
931
            # Before ending tool_call,
            # ensure function is closed to complete missing right brace
            if self.current_function_open:
                # If there are still unclosed parameters, close them first
                if self.current_param_name:
932
                    self._end_element("parameter")
933
                # Close function, ensure output '}' or '{}'
934
                self._end_element("function")
935
            # Final Delta
936
937
938
939
940
941
942
943
944
945
            delta = DeltaMessage(
                tool_calls=[
                    DeltaToolCall(
                        index=self.tool_call_index - 1,
                        id=self.current_call_id,
                        type="function",
                        function=DeltaFunctionCall(name=None, arguments=""),
                    )
                ]
            )
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
            self._emit_delta(delta)

            # Check if there's text content to output (between tool_calls)
            if self.text_content_buffer.strip():
                text_delta = DeltaMessage(content=self.text_content_buffer)
                self._emit_delta(text_delta)

            self._reset_xml_parser_after_tool_call()

    def setup_parser(self):
        """Set up XML parser event handlers"""
        self.parser.buffer_text = True
        self.parser.StartElementHandler = self._start_element
        self.parser.EndElementHandler = self._end_element
        self.parser.CharacterDataHandler = self._char_data

962
    def set_tools(self, tools: list[ChatCompletionToolsParam] | None):
963
964
965
        """Set tool configuration information"""
        self.tools = tools

966
    def _extract_function_name(self, name: str, attrs: dict[str, str]) -> str | None:
967
        """Extract function name from various formats"""
968
969
        if attrs and "name" in attrs:
            return attrs["name"]
970

971
972
973
        if "=" in name:
            parts = name.split("=", 1)
            if len(parts) == 2 and parts[0] == "function":
974
975
976
977
                return parts[1]

        return None

978
    def _extract_parameter_name(self, name: str, attrs: dict[str, str]) -> str | None:
979
        """Extract parameter name from various formats"""
980
981
        if attrs and "name" in attrs:
            return attrs["name"]
982

983
984
985
        if "=" in name:
            parts = name.split("=", 1)
            if len(parts) == 2 and parts[0] == "parameter":
986
987
988
989
990
991
992
993
994
995
996
997
998
                return parts[1]

        return None

    def _get_param_type(self, param_name: str) -> str:
        """Get parameter type based on tool configuration, defaults to string
        Args:
            param_name: Parameter name

        Returns:
            Parameter type
        """
        if not self.tools or not self.current_function_name:
999
            return "string"
1000
1001

        for tool in self.tools:
1002
1003
1004
            if not hasattr(tool, "type") or not (
                hasattr(tool, "function") and hasattr(tool.function, "name")
            ):
1005
                continue
1006
1007
1008
1009
1010
1011
            if (
                tool.type == "function"
                and tool.function.name == self.current_function_name
            ):
                if not hasattr(tool.function, "parameters"):
                    return "string"
1012
                params = tool.function.parameters
1013
1014
                if isinstance(params, dict) and "properties" in params:
                    properties = params["properties"]
1015
                    if param_name in properties and isinstance(
1016
1017
                        properties[param_name], dict
                    ):
1018
                        return self.repair_param_type(
1019
1020
                            str(properties[param_name].get("type", "string"))
                        )
1021
1022
1023
1024
                elif isinstance(params, dict) and param_name in params:
                    param_config = params[param_name]
                    if isinstance(param_config, dict):
                        return self.repair_param_type(
1025
1026
                            str(param_config.get("type", "string"))
                        )
1027
                break
1028
        return "string"
1029
1030
1031
1032
1033
1034
1035
1036
1037

    def repair_param_type(self, param_type: str) -> str:
        """Repair unknown parameter types by treating them as string
        Args:
            param_type: Parameter type

        Returns:
            Repaired parameter type
        """
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
        if (
            param_type in ["string", "str", "text", "varchar", "char", "enum"]
            or param_type.startswith("int")
            or param_type.startswith("uint")
            or param_type.startswith("long")
            or param_type.startswith("short")
            or param_type.startswith("unsigned")
            or param_type.startswith("num")
            or param_type.startswith("float")
            or param_type in ["boolean", "bool", "binary"]
            or (
                param_type in ["object", "array", "arr", "sequence"]
                or param_type.startswith("dict")
                or param_type.startswith("list")
            )
        ):
1054
1055
            return param_type
        else:
1056
            return "string"
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066

    def _convert_param_value(self, param_value: str, param_type: str) -> Any:
        """Convert value based on parameter type
        Args:
            param_value: Parameter value
            param_type: Parameter type

        Returns:
            Converted value
        """
1067
        if param_value.lower() == "null":
1068
1069
1070
            return None

        param_type = param_type.strip().lower()
1071
        if param_type in ["string", "str", "text", "varchar", "char", "enum"]:
1072
            return param_value
1073
1074
1075
1076
1077
1078
1079
        elif (
            param_type.startswith("int")
            or param_type.startswith("uint")
            or param_type.startswith("long")
            or param_type.startswith("short")
            or param_type.startswith("unsigned")
        ):
1080
1081
1082
1083
1084
            try:
                return int(param_value)
            except (ValueError, TypeError):
                logger.warning(
                    "Parsed value '%s' of parameter '%s' is not an integer "
1085
1086
1087
                    "in tool '%s', degenerating to string.",
                    param_value,
                )
1088
            return param_value
1089
        elif param_type.startswith("num") or param_type.startswith("float"):
1090
1091
            try:
                float_param_value: float = float(param_value)
1092
1093
1094
1095
1096
                return (
                    float_param_value
                    if float_param_value - int(float_param_value) != 0
                    else int(float_param_value)
                )
1097
1098
1099
            except (ValueError, TypeError):
                logger.warning(
                    "Parsed value '%s' of parameter '%s' is not a float "
1100
1101
1102
                    "in tool '%s', degenerating to string.",
                    param_value,
                )
1103
            return param_value
1104
        elif param_type in ["boolean", "bool", "binary"]:
1105
            param_value = param_value.lower()
1106
            return param_value == "true"
1107
1108
1109
        else:
            return param_value

1110
1111
    def _convert_for_json_streaming(self, converted_value: Any, param_type: str) -> str:
        """Convert converted_value based on
1112
1113
1114
1115
1116
1117
1118
1119
1120
        whether it's empty and if type is string
        Args:
            converted_value: Converted value
            param_type: Parameter type

        Returns:
            Converted string for streaming output
        """
        # Check if value is empty, but exclude numeric 0
1121
1122
        if converted_value is None or converted_value == "":
            return ""
1123

1124
        if param_type in ["string", "str", "text", "varchar", "char", "enum"]:
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
            # String type, remove double quotes
            return json.dumps(converted_value, ensure_ascii=False)[1:-1]
        else:
            # Non-string type, return complete JSON string
            if not isinstance(converted_value, str):
                return json.dumps(converted_value, ensure_ascii=False)
            else:
                return converted_value

    def _reset_xml_parser_after_tool_call(self):
        """
1136
        Each tool_call is treated as a separate XML document,
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
        so we need to reset the parser after each tool_call.
        """

        # recreate XML parser
        self.parser = ParserCreate()
        self.setup_parser()

        # Reset current tool_call state
        if self.current_call_id:
            self.last_completed_call_id = self.current_call_id
        self.current_call_id = None
        self.current_function_name = None
        self.current_function_open = False
        self.parameters = {}
        self.current_param_name = None
1152
1153
        self.current_param_value = ""
        self.current_param_value_converted = ""
1154
1155
1156
        self.current_param_is_first = False
        self.should_emit_end_newline = False
        self.start_quote_emitted = False
1157
        self.text_content_buffer = ""
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167

        # Reset preprocessing and deferred parsing state
        self._pre_inside_parameter = False
        self._pre_param_buffer = ""
        self._pre_current_param_name = None
        self.defer_current_parameter = False
        self.deferred_param_raw_value = ""


class Qwen3XMLToolParser(ToolParser):
1168
    def __init__(self, tokenizer: TokenizerLike):
1169
1170
1171
        super().__init__(tokenizer)
        self.parser = StreamingXMLToolCallParser()

1172
1173
1174
1175
        # Add missing attributes for compatibility with serving_chat.py
        self.prev_tool_call_arr: list[dict] = []
        self.streamed_args_for_tool: list[str] = []

1176
1177
1178
        logger.info(
            "vLLM Successfully import tool parser %s !", self.__class__.__name__
        )
1179
1180
1181
1182
1183
1184
1185

    def extract_tool_calls(
        self,
        model_output: str,
        request: ChatCompletionRequest,
    ) -> ExtractedToolCallInformation:
        self.parser.reset_streaming_state()
1186
1187
1188
        # Reset tool call tracking arrays for new extraction
        self.prev_tool_call_arr = []
        self.streamed_args_for_tool = []
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
        if request:
            self.parser.set_tools(request.tools)
        result = self.parser.parse_single_streaming_chunks(model_output)
        if not result.tool_calls:
            return ExtractedToolCallInformation(
                tool_calls=[],
                tools_called=False,
                content=result.content,
            )
        else:
            tool_calls = []
            for tool_call in result.tool_calls:
                if tool_call.function and tool_call.function.name:
                    tool_calls.append(
                        ToolCall(
                            id=tool_call.id,
                            type=tool_call.type,
                            function=FunctionCall(
                                name=tool_call.function.name,
                                arguments=tool_call.function.arguments,
                            ),
1210
1211
                        )
                    )
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239

                    # Update tool call tracking arrays for compatibility
                    tool_index = (
                        tool_call.index
                        if tool_call.index is not None
                        else len(self.prev_tool_call_arr) - 1
                    )

                    # Ensure we have enough entries in our tracking arrays
                    while len(self.prev_tool_call_arr) <= tool_index:
                        self.prev_tool_call_arr.append({"name": "", "arguments": ""})
                    while len(self.streamed_args_for_tool) <= tool_index:
                        self.streamed_args_for_tool.append("")

                    # Update tool call information
                    self.prev_tool_call_arr[tool_index]["name"] = (
                        tool_call.function.name
                    )
                    self.prev_tool_call_arr[tool_index]["arguments"] = (
                        tool_call.function.arguments
                    )

                    # Update streamed arguments
                    if tool_call.function.arguments:
                        self.streamed_args_for_tool[tool_index] = (
                            tool_call.function.arguments
                        )

1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
            return ExtractedToolCallInformation(
                tool_calls=tool_calls,
                tools_called=len(tool_calls) > 0,
                content=result.content,
            )

    def extract_tool_calls_streaming(
        self,
        previous_text: str,
        current_text: str,
        delta_text: str,
        previous_token_ids: Sequence[int],
        current_token_ids: Sequence[int],
        delta_token_ids: Sequence[int],
        request: ChatCompletionRequest,
1255
    ) -> DeltaMessage | None:
1256
1257
        if not previous_text:
            self.parser.reset_streaming_state()
1258
1259
1260
            # Reset tool call tracking arrays for new streaming session
            self.prev_tool_call_arr = []
            self.streamed_args_for_tool = []
1261
1262
1263
1264
1265
1266
1267
1268
1269
            if request:
                self.parser.set_tools(request.tools)

        # Model sometimes outputs separately causing delta_text to be empty.
        # If there were tool_calls before and all current tool_calls have ended,
        # return an empty tool_call for outer streaming output
        # to correctly output tool_call field
        if not delta_text and delta_token_ids:
            open_calls = current_text.count(
1270
1271
                self.parser.tool_call_start_token
            ) - current_text.count(self.parser.tool_call_end_token)
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
            if (
                open_calls == 0
                and self.parser.tool_call_index > 0
                or not self.parser.tool_call_index
                and current_text
            ):
                return DeltaMessage(content="")
            return None

        # Parse the delta text and get the result
        result = self.parser.parse_single_streaming_chunks(delta_text)

        # Update tool call tracking arrays based on incremental parsing results
        if result and result.tool_calls:
            for tool_call in result.tool_calls:
                if tool_call.function:
                    tool_index = (
                        tool_call.index
                        if tool_call.index is not None
                        else len(self.prev_tool_call_arr) - 1
                    )

                    # Ensure we have enough entries in our tracking arrays
                    while len(self.prev_tool_call_arr) <= tool_index:
                        self.prev_tool_call_arr.append({"name": "", "arguments": ""})
                    while len(self.streamed_args_for_tool) <= tool_index:
                        self.streamed_args_for_tool.append("")

                    # Update tool name if provided
                    if tool_call.function.name:
                        self.prev_tool_call_arr[tool_index]["name"] = (
                            tool_call.function.name
1304
                        )
1305

1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
                    # Update arguments incrementally
                    if tool_call.function.arguments is not None:
                        # Concatenate the incremental arguments
                        # to the existing streamed arguments
                        self.prev_tool_call_arr[tool_index]["arguments"] += (
                            tool_call.function.arguments
                        )
                        self.streamed_args_for_tool[tool_index] += (
                            tool_call.function.arguments
                        )
        return result