seed_oss_tool_parser.py 30.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
# Adapted from qwen3coder xml parser, All rights reserved.
# ruff: noqa: E501

import ast
import json
import uuid
from collections.abc import Sequence
10
from typing import Any
11
12
13

import regex as re

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

logger = init_logger(__name__)


class SeedOssToolParser(ToolParser):
    TOOL_CALL_START = "<seed:tool_call>"
    TOOL_CALL_END = "</seed:tool_call>"

39
    def __init__(self, tokenizer: TokenizerLike):
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
        super().__init__(tokenizer)

        # --- streaming state ---
        self._reset_streaming_state()
        self.prev_tool_call_arr: list[dict] = []

        self.tool_call_start_token: str = self.TOOL_CALL_START
        self.tool_call_end_token: str = self.TOOL_CALL_END
        # Sentinel tokens for streaming mode
        self.tool_call_prefix: str = "<function="
        self.function_end_token: str = "</function>"
        self.parameter_prefix: str = "<parameter="
        self.parameter_end_token: str = "</parameter>"
        self.think_start_token: str = "<seed:think>"
        self.think_end_token: str = "</seed:think>"
        self.is_tool_call_started: bool = False
        self.is_thinking_end: bool = False
        self.failed_count: int = 0
        self._reset_streaming_state()

60
        self.tool_call_start_token_id = self.vocab.get(self.tool_call_start_token)
61
62
63
        self.tool_call_end_token_id = self.vocab.get(self.tool_call_end_token)
        self.think_end_token_id = self.vocab.get(self.think_end_token)

64
        if self.tool_call_start_token_id is None or self.tool_call_end_token_id is None:
65
66
            raise RuntimeError(
                "Seed_Oss XML parser: tokenizer did not include "
67
68
                "<seed:tool_call> or its closing tag."
            )
69
70
71
72
73

        tool_start_re = re.escape(self.tool_call_start_token)
        tool_end_re = re.escape(self.tool_call_end_token)

        self.tool_call_complete_regex = re.compile(
74
75
            rf"{tool_start_re}(.*?){tool_end_re}", re.DOTALL
        )
76
        self.tool_call_regex = re.compile(
77
78
            rf"{tool_start_re}(.*?){tool_end_re}|{tool_start_re}(.*?)$", re.DOTALL
        )
79
80

        self.tool_call_function_regex = re.compile(
81
82
            r"<function=(.*?)</function>|<function=(.*)$", re.DOTALL
        )
83
        self.tool_call_parameter_regex = re.compile(
84
85
            r"<parameter=(.*?)</parameter>|<parameter=(.*?)$", re.DOTALL
        )
86

87
88
89
        logger.info(
            "vLLM Seed-Oss XML tool parser loaded (%s).", self.__class__.__name__
        )
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

    def _generate_tool_call_id(self) -> str:
        """Generate a unique tool call ID."""
        return f"call_{uuid.uuid4().hex[:24]}"

    def _reset_streaming_state(self):
        """Reset all streaming state."""
        self.current_tool_index = 0
        self.is_tool_call_started = False
        self.header_sent = False
        self.current_tool_id = -1
        self.current_function_name = None
        self.current_param_name = None
        self.current_param_value = ""
        self.param_count = 0
        self.in_param = False
        self.in_function = False
        self.accumulated_text = ""
        self.json_started = False
        self.json_closed = False

    def _parse_xml_function_call(
112
113
        self, function_call_str: str, tools: list[ChatCompletionToolsParam] | None
    ) -> ToolCall | None:
114
115
116
117
118
        def get_arguments_config(func_name: str) -> dict:
            if tools is None:
                return {}
            for config in tools:
                if not hasattr(config, "type") or not (
119
120
                    hasattr(config, "function") and hasattr(config.function, "name")
                ):
121
                    continue
122
                if config.type == "function" and config.function.name == func_name:
123
124
125
126
127
128
129
130
131
                    if not hasattr(config.function, "parameters"):
                        return {}
                    params = config.function.parameters
                    if isinstance(params, dict) and "properties" in params:
                        return params["properties"]
                    elif isinstance(params, dict):
                        return params
                    else:
                        return {}
132
            logger.warning("Tool '%s' is not defined in the tools list.", func_name)
133
134
            return {}

135
136
137
        def convert_param_value(
            param_value: str, param_name: str, param_config: dict, func_name: str
        ) -> Any:
138
139
140
141
142
143
144
145
146
            # Handle null value for any type
            if param_value.lower() == "null":
                return None

            if param_name not in param_config:
                if param_config != {}:
                    logger.warning(
                        "Parsed parameter '%s' is not defined in "
                        "the tool parameters for tool '%s', "
147
148
149
150
                        "directly returning the string value.",
                        param_name,
                        func_name,
                    )
151
152
                return param_value

153
154
155
156
157
            if (
                isinstance(param_config[param_name], dict)
                and "type" in param_config[param_name]
            ):
                param_type = str(param_config[param_name]["type"]).strip().lower()
158
159
            else:
                param_type = "string"
160
            if param_type in ["string", "str", "text", "varchar", "char", "enum"]:
161
                return param_value
162
163
164
165
166
167
168
            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")
            ):
169
170
171
172
173
                try:
                    param_value = int(param_value)  # type: ignore
                except (ValueError, TypeError):
                    logger.warning(
                        "Parsed value '%s' of parameter '%s' is not an integer in tool "
174
175
176
177
178
                        "'%s', degenerating to string.",
                        param_value,
                        param_name,
                        func_name,
                    )
179
                return param_value
180
            elif param_type.startswith("num") or param_type.startswith("float"):
181
182
                try:
                    float_param_value = float(param_value)
183
184
185
186
187
                    param_value = (
                        float_param_value  # type: ignore
                        if float_param_value - int(float_param_value) != 0
                        else int(float_param_value)  # type: ignore
                    )
188
189
190
                except (ValueError, TypeError):
                    logger.warning(
                        "Parsed value '%s' of parameter '%s' is not a float in tool "
191
192
193
194
195
                        "'%s', degenerating to string.",
                        param_value,
                        param_name,
                        func_name,
                    )
196
197
198
199
200
201
202
                return param_value
            elif param_type in ["boolean", "bool", "binary"]:
                param_value = param_value.lower()
                if param_value not in ["true", "false"]:
                    logger.warning(
                        "Parsed value '%s' of parameter '%s' is not a boolean "
                        "(`true` of `false`) in tool '%s', degenerating to false.",
203
204
205
206
                        param_value,
                        param_name,
                        func_name,
                    )
207
208
209
210
211
212
213
214
215
216
                return param_value == "true"
            else:
                if param_type == "object" or param_type.startswith("dict"):
                    try:
                        param_value = json.loads(param_value)
                        return param_value
                    except (ValueError, TypeError, json.JSONDecodeError):
                        logger.warning(
                            "Parsed value '%s' of parameter '%s' is not a valid JSON "
                            "object in tool '%s', will try other methods to parse it.",
217
218
219
220
                            param_value,
                            param_name,
                            func_name,
                        )
221
222
223
224
225
226
                try:
                    param_value = ast.literal_eval(param_value)
                except (ValueError, SyntaxError):
                    logger.warning(
                        "Parsed value '%s' of parameter '%s' cannot be converted via "
                        "Python `ast.literal_eval()` in tool '%s', degenerating to string.",
227
228
229
230
                        param_value,
                        param_name,
                        func_name,
                    )
231
232
233
234
235
236
                return param_value

        # Extract function name
        end_index = function_call_str.index(">")
        function_name = function_call_str[:end_index]
        param_config = get_arguments_config(function_name)
237
        parameters = function_call_str[end_index + 1 :]
238
239
240
241
242
        param_dict = {}
        for match in self.tool_call_parameter_regex.findall(parameters):
            match_text = match[0] if match[0] else match[1]
            idx = match_text.index(">")
            param_name = match_text[:idx]
243
            param_value = str(match_text[idx + 1 :])
244
245
246
247
248
249
250
            # Remove prefix and trailing \n
            if param_value.startswith("\n"):
                param_value = param_value[1:]
            if param_value.endswith("\n"):
                param_value = param_value[:-1]

            param_dict[param_name] = convert_param_value(
251
252
                param_value, param_name, param_config, function_name
            )
253
254
        return ToolCall(
            type="function",
255
256
257
            function=FunctionCall(
                name=function_name, arguments=json.dumps(param_dict, ensure_ascii=False)
            ),
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
        )

    def _get_function_calls(self, model_output: str) -> list[str]:
        # Find all tool calls
        matched_ranges = self.tool_call_regex.findall(model_output)
        raw_tool_calls = [
            match[0] if match[0] else match[1] for match in matched_ranges
        ]

        # Back-off strategy if no tool_call tags found
        if len(raw_tool_calls) == 0:
            raw_tool_calls = [model_output]

        raw_function_calls = []
        for tool_call in raw_tool_calls:
273
            raw_function_calls.extend(self.tool_call_function_regex.findall(tool_call))
274
275
276
277
278
279
280
281
282
283
284
285
286

        function_calls = [
            match[0] if match[0] else match[1] for match in raw_function_calls
        ]
        return function_calls

    def extract_tool_calls(
        self,
        model_output: str,
        request: ChatCompletionRequest,
    ) -> ExtractedToolCallInformation:
        # Quick check to avoid unnecessary processing
        if self.tool_call_prefix not in model_output:
287
288
289
            return ExtractedToolCallInformation(
                tools_called=False, tool_calls=[], content=model_output
            )
290
291

        # Check if both think start and end tokens are present
292
293
294
295
        if (
            self.think_start_token in model_output
            and self.think_end_token in model_output
        ):
296
297
            # Find the position of think end token
            think_end_index = model_output.find(self.think_end_token) + len(
298
299
                self.think_end_token
            )
300
301
302
            # Extract content after think end token
            result_content = model_output[think_end_index:]
            thinking_content = model_output[:think_end_index]
Bin Jia's avatar
Bin Jia committed
303
304
305
        else:
            thinking_content = ""
            result_content = model_output
306
307
308
309

        try:
            function_calls = self._get_function_calls(result_content)
            if len(function_calls) == 0:
310
311
312
                return ExtractedToolCallInformation(
                    tools_called=False, tool_calls=[], content=model_output
                )
313
314
315
316
317
318
319
320
321
322

            tool_calls = [
                self._parse_xml_function_call(function_call_str, request.tools)
                for function_call_str in function_calls
            ]

            # Populate prev_tool_call_arr for serving layer to set finish_reason
            self.prev_tool_call_arr.clear()  # Clear previous calls
            for tool_call in tool_calls:
                if tool_call:
323
324
325
326
327
328
                    self.prev_tool_call_arr.append(
                        {
                            "name": tool_call.function.name,
                            "arguments": tool_call.function.arguments,
                        }
                    )
329
330

            # Extract content before tool calls
331
            tool_call_start_index = result_content.find(self.tool_call_start_token)
332
            tool_call_start_index = (
333
334
335
336
                tool_call_start_index
                if tool_call_start_index >= 0
                else result_content.find(self.tool_call_prefix)
            )
337
338
339
340
341
342
343
344
345
346
            content = thinking_content + result_content[:tool_call_start_index]

            return ExtractedToolCallInformation(
                tools_called=(len(tool_calls) > 0),
                tool_calls=tool_calls,
                content=content if content else None,
            )

        except Exception:
            logger.exception("Error in extracting tool call from response.")
347
348
349
            return ExtractedToolCallInformation(
                tools_called=False, tool_calls=[], content=model_output
            )
350
351
352
353
354
355
356
357
358
359

    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,
360
    ) -> DeltaMessage | None:
361
362
363
364
365
366
        # If no delta text, return None unless
        # it's an EOS token after tool calls
        if not delta_text:
            # Check if this is an EOS token after all tool calls are complete
            # We check for tool calls in the text even if is_tool_call_started
            # is False because it might have been reset after processing all tools
367
            if delta_token_ids and self.tool_call_end_token_id not in delta_token_ids:
368
369
                # Count complete tool calls
                complete_calls = len(
370
371
                    self.tool_call_complete_regex.findall(current_text)
                )
372
373
374
375
376

                # If we have completed tool calls and populated prev_tool_call_arr
                if complete_calls > 0 and len(self.prev_tool_call_arr) > 0:
                    # Check if all tool calls are closed
                    open_calls = current_text.count(
377
378
                        self.tool_call_start_token
                    ) - current_text.count(self.tool_call_end_token)
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
                    if open_calls == 0:
                        # Return empty delta message to allow finish_reason processing
                        return DeltaMessage(content="")
                elif not self.is_tool_call_started and current_text:
                    # This is a regular content response that's now complete
                    return DeltaMessage(content="")
            return None

        # Check if this is the first call (reset state if needed)
        if not previous_text:
            self._reset_streaming_state()

        # Update accumulated text
        self.accumulated_text = current_text

        # Check if we need to advance to next tool
        if self.json_closed and not self.in_function:
            # Check if this tool call has ended
            tool_ends = current_text.count(self.tool_call_end_token)
            if tool_ends > self.current_tool_index:
                # This tool has ended, advance to next
                self.current_tool_index += 1
                self.header_sent = False
                self.param_count = 0
                self.json_started = False
                self.json_closed = False

                # Check if there are more tool calls
                if self.current_tool_index >= current_text.count(
408
409
                    self.tool_call_start_token
                ):
410
411
412
413
414
415
                    # No more tool calls
                    self.is_tool_call_started = False
                # Continue processing next tool
                return None

        # Check if end thinking
416
417
418
419
        if not self.is_thinking_end and (
            self.think_end_token_id in delta_token_ids
            or self.think_end_token in delta_text
        ):
420
421
422
423
424
425
426
427
428
            self.is_thinking_end = True

        # If thinking hasn't ended yet, don't process any tool calls
        if not self.is_thinking_end:
            return DeltaMessage(content=delta_text)

        # Handle normal content before tool calls
        if not self.is_tool_call_started:
            # Check if tool call is starting
429
430
431
432
            if (
                self.tool_call_start_token_id in delta_token_ids
                or self.tool_call_start_token in delta_text
            ):
433
434
435
                self.is_tool_call_started = True
                # Return any content before the tool call
                if self.tool_call_start_token in delta_text:
436
437
438
                    content_before = delta_text[
                        : delta_text.index(self.tool_call_start_token)
                    ]
439
440
441
442
443
                    if content_before:
                        return DeltaMessage(content=content_before)
                return None
            else:
                # Check if we're between tool calls - skip whitespace
444
445
446
447
                if (
                    current_text.rstrip().endswith(self.tool_call_end_token)
                    and delta_text.strip() == ""
                ):
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
                    # We just ended a tool call, skip whitespace
                    return None
                # Normal content, no tool call
                return DeltaMessage(content=delta_text)

        # Check if we're between tool calls (waiting for next one)
        # Count tool calls we've seen vs processed
        tool_starts_count = current_text.count(self.tool_call_start_token)
        if self.current_tool_index >= tool_starts_count:
            # We're past all tool calls, shouldn't be here
            return None

        # We're in a tool call, find the current tool call portion
        # Need to find the correct tool call based on current_tool_index
        # Only process tool calls after think_end_token
463
464
465
466
467
        think_end_index = (
            current_text.find(self.think_end_token) + len(self.think_end_token)
            if self.think_end_token in current_text
            else 0
        )
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
        tool_starts: list[int] = []
        idx = think_end_index
        while True:
            idx = current_text.find(self.tool_call_start_token, idx)
            if idx == -1:
                break
            tool_starts.append(idx)
            idx += len(self.tool_call_start_token)

        if self.current_tool_index >= len(tool_starts):
            # No more tool calls to process yet
            return None

        tool_start_idx = tool_starts[self.current_tool_index]
        # Find where this tool call ends (or current position if not ended yet)
483
        tool_end_idx = current_text.find(self.tool_call_end_token, tool_start_idx)
484
485
486
        if tool_end_idx == -1:
            tool_text = current_text[tool_start_idx:]
        else:
487
488
489
            tool_text = current_text[
                tool_start_idx : tool_end_idx + len(self.tool_call_end_token)
            ]
490
491
492
493
494

        # Looking for function header
        if not self.header_sent:
            if self.tool_call_prefix in tool_text:
                func_start = tool_text.find(self.tool_call_prefix) + len(
495
496
                    self.tool_call_prefix
                )
497
498
499
500
501
                func_end = tool_text.find(">", func_start)

                if func_end != -1:
                    # Found complete function name
                    self.current_function_name = tool_text[func_start:func_end]
502
                    self.current_tool_id = self._generate_tool_call_id()  # type: ignore
503
504
505
506
507
508
509
                    self.header_sent = True
                    self.in_function = True

                    # IMPORTANT: Add to prev_tool_call_arr immediately when we detect a tool call
                    # This ensures finish_reason="tool_calls" even if parsing isn't complete
                    already_added = any(
                        tool.get("name") == self.current_function_name
510
511
                        for tool in self.prev_tool_call_arr
                    )
512
                    if not already_added:
513
514
515
516
517
518
                        self.prev_tool_call_arr.append(
                            {
                                "name": self.current_function_name,
                                "arguments": "{}",  # Placeholder, will be updated later
                            }
                        )
519
520

                    # Send header with function info
521
522
523
524
525
526
527
528
529
530
531
532
                    return DeltaMessage(
                        tool_calls=[
                            DeltaToolCall(
                                index=self.current_tool_index,
                                id=self.current_tool_id,
                                function=DeltaFunctionCall(
                                    name=self.current_function_name, arguments=""
                                ),
                                type="function",
                            )
                        ]
                    )
533
534
535
536
537
            return None

        # We've sent header, now handle function body
        if self.in_function:
            # Send opening brace if not sent yet
538
            if not self.json_started and self.parameter_prefix not in delta_text:
539
                self.json_started = True
540
541
542
543
544
545
546
547
                return DeltaMessage(
                    tool_calls=[
                        DeltaToolCall(
                            index=self.current_tool_index,
                            function=DeltaFunctionCall(arguments="{"),
                        )
                    ]
                )
548
549
550
551
552
553
554
555
556
557
558
559
560

            # Make sure json_started is set if we're processing parameters
            if not self.json_started:
                self.json_started = True

            # Check for function end in accumulated text
            if not self.json_closed and self.function_end_token in tool_text:
                # Close JSON
                self.json_closed = True

                # Extract the complete tool call to update prev_tool_call_arr with final arguments
                # Find the function content
                func_start = tool_text.find(self.tool_call_prefix) + len(
561
562
563
                    self.tool_call_prefix
                )
                func_content_end = tool_text.find(self.function_end_token, func_start)
564
565
566
567
568
                if func_content_end != -1:
                    func_content = tool_text[func_start:func_content_end]
                    # Parse to get the complete arguments
                    try:
                        parsed_tool = self._parse_xml_function_call(
569
570
                            func_content, request.tools if request else None
                        )
571
572
573
                        if parsed_tool:
                            # Update existing entry in prev_tool_call_arr with complete arguments
                            for i, tool in enumerate(self.prev_tool_call_arr):
574
                                if tool.get("name") == parsed_tool.function.name:
575
                                    self.prev_tool_call_arr[i]["arguments"] = (
576
577
                                        parsed_tool.function.arguments
                                    )
578
579
580
581
                                    break
                    except Exception:
                        logger.warning(
                            "Failed to parse tool arguments during streaming.",
582
583
                            exc_info=True,
                        )
584

585
586
587
588
589
590
591
592
                result = DeltaMessage(
                    tool_calls=[
                        DeltaToolCall(
                            index=self.current_tool_index,
                            function=DeltaFunctionCall(arguments="}"),
                        )
                    ]
                )
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634

                # Reset state for next tool
                self.in_function = False
                self.json_closed = True

                return result

            # Look for parameters
            # Count how many complete parameters we have processed
            complete_params = tool_text.count(self.parameter_end_token)

            # Check if we should start a new parameter
            if not self.in_param and self.param_count < complete_params:
                # Find the unprocessed parameter
                # Count parameter starts
                param_starts = []
                idx = 0
                while True:
                    idx = tool_text.find(self.parameter_prefix, idx)
                    if idx == -1:
                        break
                    param_starts.append(idx)
                    idx += len(self.parameter_prefix)

                if len(param_starts) > self.param_count:
                    # Process the next parameter
                    param_idx = param_starts[self.param_count]
                    param_start = param_idx + len(self.parameter_prefix)
                    remaining = tool_text[param_start:]

                    if ">" in remaining:
                        # We have the complete parameter name
                        name_end = remaining.find(">")
                        self.current_param_name = remaining[:name_end]

                        # Find the parameter value
                        value_start = param_start + name_end + 1
                        value_text = tool_text[value_start:]
                        if value_text.startswith("\n"):
                            value_text = value_text[1:]

                        # Find where this parameter ends
635
                        param_end_idx = value_text.find(self.parameter_end_token)
636
637
638
639
640
641
642
643
644
                        if param_end_idx != -1:
                            # Complete parameter found
                            param_value = value_text[:param_end_idx]
                            if param_value.endswith("\n"):
                                param_value = param_value[:-1]

                            # Build complete JSON fragment for this parameter
                            if self.param_count == 0:
                                json_fragment = (
645
646
647
648
649
650
                                    '"'
                                    + self.current_param_name
                                    + '": "'
                                    + json.dumps(param_value)[1:-1]
                                    + '"'
                                )
651
652
                            else:
                                json_fragment = (
653
654
655
656
657
658
                                    ', "'
                                    + self.current_param_name
                                    + '": "'
                                    + json.dumps(param_value)[1:-1]
                                    + '"'
                                )
659
660
661

                            self.param_count += 1

662
663
664
665
666
667
668
669
670
671
                            return DeltaMessage(
                                tool_calls=[
                                    DeltaToolCall(
                                        index=self.current_tool_index,
                                        function=DeltaFunctionCall(
                                            arguments=json_fragment
                                        ),
                                    )
                                ]
                            )
672
673
674
675
676
677
678
679
680
681
682

            # Continue parameter value
            if self.in_param:
                if self.parameter_end_token in delta_text:
                    # End of parameter
                    end_idx = delta_text.find(self.parameter_end_token)
                    value_chunk = delta_text[:end_idx]

                    # Skip past > if at start
                    if not self.current_param_value and ">" in value_chunk:
                        gt_idx = value_chunk.find(">")
683
                        value_chunk = value_chunk[gt_idx + 1 :]
684

685
                    if not self.current_param_value and value_chunk.startswith("\n"):
686
687
688
689
                        value_chunk = value_chunk[1:]

                    # Calculate incremental JSON
                    full_value = self.current_param_value + value_chunk
690
691
692
693
694
                    prev_escaped = (
                        json.dumps(self.current_param_value)[1:-1]
                        if self.current_param_value
                        else ""
                    )
695
                    full_escaped = json.dumps(full_value)[1:-1]
696
                    delta_escaped = full_escaped[len(prev_escaped) :]
697
698
699
700

                    self.in_param = False
                    self.current_param_value = ""

701
702
703
704
705
706
707
708
709
710
                    return DeltaMessage(
                        tool_calls=[
                            DeltaToolCall(
                                index=self.current_tool_index,
                                function=DeltaFunctionCall(
                                    arguments=delta_escaped + '"'
                                ),
                            )
                        ]
                    )
711
712
713
714
715
716
717
                else:
                    # Continue accumulating value
                    value_chunk = delta_text

                    # Handle first chunk after param name
                    if not self.current_param_value and ">" in value_chunk:
                        gt_idx = value_chunk.find(">")
718
                        value_chunk = value_chunk[gt_idx + 1 :]
719

720
                    if not self.current_param_value and value_chunk.startswith("\n"):
721
722
723
724
                        value_chunk = value_chunk[1:]

                    if value_chunk:
                        # Stream the escaped delta
725
726
727
728
729
                        prev_escaped = (
                            json.dumps(self.current_param_value)[1:-1]
                            if self.current_param_value
                            else ""
                        )
730
                        self.current_param_value += value_chunk
731
732
                        full_escaped = json.dumps(self.current_param_value)[1:-1]
                        delta_escaped = full_escaped[len(prev_escaped) :]
733
734

                        if delta_escaped:
735
736
737
738
739
740
741
742
743
744
                            return DeltaMessage(
                                tool_calls=[
                                    DeltaToolCall(
                                        index=self.current_tool_index,
                                        function=DeltaFunctionCall(
                                            arguments=delta_escaped
                                        ),
                                    )
                                ]
                            )
745
746

        return None