[Tool Parser] Normalize nested arguments in DeepSeek DSML tool calls

[BruceXcluding]

Purpose

This PR fixes DeepSeek DSML tool-call argument normalization for OpenAI-compatible tool calls.

DeepSeek V4 Flash may emit a single DSML parameter named arguments that contains the actual function argument object, for example:

<｜DSML｜parameter name="arguments" string="false">
{"path": "/tmp/test.txt", "content": "hello"}
</｜DSML｜parameter>

The current parser converts this into OpenAI function.arguments as:

{"arguments": {"path": "/tmp/test.txt", "content": "hello"}}

However, downstream OpenAI-compatible tool validators expect the actual argument object at the top level:

{"path": "/tmp/test.txt", "content": "hello"}

This PR adds normalization for this single top-level arguments wrapper. When the parsed DSML parameters contain only one top-level key named arguments, and the value is either a dict or a JSON object string, the parser unwraps it into the actual function argument object.

This PR also updates the non-streaming path to use the same _convert_params_with_schema() conversion logic as the streaming path. Before this change, the streaming path converted parameters through _convert_params_with_schema(), while the non-streaming path directly serialized the raw param_dict. This made stream=true and stream=false behavior inconsistent.

Normal multi-parameter tool calls are preserved unchanged.

Test Plan

Added and ran parser-level tests covering:

1. Normal multi-parameter tool calls are preserved unchanged.
2. Nested arguments wrapper is normalized when the wrapper value is a dict.
3. Nested arguments wrapper is normalized when the wrapper value is a JSON object string.
4. Streaming nested arguments wrapper is emitted as OpenAI-compatible function.arguments.
5. Non-streaming nested arguments wrapper is emitted as OpenAI-compatible function.arguments.

Test command:

python3 /tmp/test_deepseek_v4_tool_parser.py

Test script:

import json
import sys

sys.path.insert(0, "/usr/local/lib/python3.12/dist-packages")

from vllm.tool_parsers.deepseekv4_tool_parser import DeepSeekV4ToolParser


class DummyTokenizer:
    pass


class Function:
    def __init__(self, name, parameters):
        self.name = name
        self.parameters = parameters


class Tool:
    def __init__(self, name, parameters):
        self.function = Function(name, parameters)


class DummyRequest:
    pass


def make_write_tool():
    return Tool(
        "write",
        {
            "type": "object",
            "properties": {
                "path": {"type": "string"},
                "content": {"type": "string"},
            },
            "required": ["path", "content"],
        },
    )


def test_keep_normal_multi_param_arguments():
    parser = DeepSeekV4ToolParser(DummyTokenizer(), tools=[make_write_tool()])

    converted = parser._convert_params_with_schema(
        "write",
        {
            "path": "/tmp/test.txt",
            "content": "hello",
        },
    )

    assert converted == {
        "path": "/tmp/test.txt",
        "content": "hello",
    }

    print("PASS: keep normal multi-param arguments")


def test_unwrap_nested_arguments_dict():
    parser = DeepSeekV4ToolParser(DummyTokenizer(), tools=[make_write_tool()])

    converted = parser._convert_params_with_schema(
        "write",
        {
            "arguments": {
                "path": "/tmp/test.txt",
                "content": "hello",
            }
        },
    )

    assert converted == {
        "path": "/tmp/test.txt",
        "content": "hello",
    }

    print("PASS: unwrap nested dict arguments")


def test_unwrap_nested_arguments_json_string():
    parser = DeepSeekV4ToolParser(DummyTokenizer(), tools=[make_write_tool()])

    converted = parser._convert_params_with_schema(
        "write",
        {
            "arguments": '{"path": "/tmp/test.txt", "content": "hello"}',
        },
    )

    assert converted == {
        "path": "/tmp/test.txt",
        "content": "hello",
    }

    print("PASS: unwrap nested JSON-string arguments")


def test_streaming_unwrap_nested_arguments():
    parser = DeepSeekV4ToolParser(DummyTokenizer(), tools=[make_write_tool()])

    chunks = [
        "<｜DSML｜tool_calls>\n",
        '<｜DSML｜invoke name="write">\n',
        '<｜DSML｜parameter name="arguments" string="false">',
        '{"path": "/tmp/test.txt", "content": "hello"}',
        "</｜DSML｜parameter>\n",
        "</｜DSML｜invoke>\n",
        "</｜DSML｜tool_calls>",
    ]

    current_text = ""
    previous_text = ""
    all_tool_calls = []

    for chunk in chunks:
        previous_text = current_text
        current_text += chunk

        delta = parser.extract_tool_calls_streaming(
            previous_text=previous_text,
            current_text=current_text,
            delta_text=chunk,
            previous_token_ids=[],
            current_token_ids=[1],
            delta_token_ids=[1],
            request=DummyRequest(),
        )

        if delta and delta.tool_calls:
            all_tool_calls.extend(delta.tool_calls)

    assert all_tool_calls, "expected parsed tool call"

    args = json.loads(all_tool_calls[0].function.arguments)

    assert args == {
        "path": "/tmp/test.txt",
        "content": "hello",
    }
    assert "arguments" not in args

    print("PASS: streaming unwraps nested arguments wrapper")


def test_non_streaming_unwrap_nested_arguments():
    parser = DeepSeekV4ToolParser(DummyTokenizer(), tools=[make_write_tool()])

    model_output = (
        "<｜DSML｜tool_calls>\n"
        '<｜DSML｜invoke name="write">\n'
        '<｜DSML｜parameter name="arguments" string="false">'
        '{"path": "/tmp/test.txt", "content": "hello"}'
        "</｜DSML｜parameter>\n"
        "</｜DSML｜invoke>\n"
        "</｜DSML｜tool_calls>"
    )

    result = parser.extract_tool_calls(
        model_output=model_output,
        request=DummyRequest(),
    )

    assert result.tools_called
    assert result.tool_calls

    args = json.loads(result.tool_calls[0].function.arguments)

    assert args == {
        "path": "/tmp/test.txt",
        "content": "hello",
    }
    assert "arguments" not in args

    print("PASS: non-streaming unwraps nested arguments wrapper")


def main():
    test_keep_normal_multi_param_arguments()
    test_unwrap_nested_arguments_dict()
    test_unwrap_nested_arguments_json_string()
    test_streaming_unwrap_nested_arguments()
    test_non_streaming_unwrap_nested_arguments()

    print("\nALL TESTS PASSED")


if __name__ == "__main__":
    main()

Also verified with an internal/private OpenAI-compatible DeepSeek V4 Flash deployment.

Example request:

curl -N -X POST <internal-endpoint>/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <key>" \
  -d '{
    "model": "<internal-deepseek-v4-flash-model>",
    "messages": [{"role": "user", "content": "帮我写入文件 /tmp/test.txt，内容是 hello"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "write",
        "parameters": {
          "type": "object",
          "properties": {
            "path": {"type": "string"},
            "content": {"type": "string"}
          },
          "required": ["path", "content"]
        }
      }
    }],
    "stream": true
  }' 2>/dev/null | tee /tmp/ds_v4_write.log

Validation command:

python3 - <<'PY'
import json

path = "/tmp/ds_v4_write.log"
seen = False

with open(path, "r", encoding="utf-8") as f:
    for line in f:
        if not line.startswith("data: "):
            continue

        payload = line[len("data: "):].strip()
        if payload == "[DONE]":
            continue

        obj = json.loads(payload)
        for choice in obj.get("choices", []):
            delta = choice.get("delta", {})
            for tc in delta.get("tool_calls", []):
                fn = tc.get("function", {})
                args_s = fn.get("arguments")
                if not args_s:
                    continue

                seen = True
                args = json.loads(args_s)
                print(args)

                assert "arguments" not in args, args
                assert "path" in args, args
                assert "content" in args, args

assert seen, "no tool call arguments found"
print("PASS: online arguments are normalized")
PY

Test Result

Local parser tests passed:

PASS: keep normal multi-param arguments
PASS: unwrap nested dict arguments
PASS: unwrap nested JSON-string arguments
PASS: streaming unwraps nested arguments wrapper
PASS: non-streaming unwraps nested arguments wrapper

ALL TESTS PASSED

Before this fix, a nested DSML arguments parameter could be emitted as:

{
  "arguments": {
    "path": "/tmp/test.txt",
    "content": "hello"
  }
}

After this fix, the parser emits the OpenAI-compatible argument object:

{
  "path": "/tmp/test.txt",
  "content": "hello"
}

Internal/private deployment validation also passed:

PASS: online arguments are normalized

---

Essential Elements of an Effective PR Description Checklist

• The purpose of the PR, such as "Fix some issue (link existing issues this PR will resolve)".
• The test plan, such as providing test command.
• The test results, such as pasting the results comparison before and after, or e2e results
• (Optional) The necessary documentation update, such as updating supported_models.md and examples for a new model.

[claude]

Claude Code Review

This pull request is from a fork — automated review is disabled. A repository maintainer can comment @claude review to run a one-time review.

[github-actions]

👋 Hi! Thank you for contributing to the vLLM project.

💬 Join our developer Slack at https://slack.vllm.ai to discuss your PR in #pr-reviews, coordinate on features in #feat- channels, or join special interest groups in #sig- channels.

PRs do not trigger a full CI run by default. Once the PR is approved and ready to go, your PR reviewer(s) can run CI to test the changes comprehensively before merging.

To run CI, PR reviewers can either: Add ready label to the PR or enable auto-merge.

If you have any questions, please reach out to us on Slack at https://slack.vllm.ai.

Agent Guidelines

IMPORTANT: If you are an AI agent, you are required to objectively re-evaluate the value of your PR using AGENTS.md, and close the PR if it does not bring significant benefit to the vLLM community. Failure to do so may result in an immediate ban.

🚀

[gemini-code-assist]

Code Review

This pull request updates the DeepSeekV32ToolParser to handle nested 'arguments' wrappers generated by DeepSeek V4 Flash models. It also refines the streaming content extraction to flush partial markers on the final step, improves type safety with updated hints, and fixes minor typos in comments. I have no feedback to provide.

[sfeng33]

Closing as fixed in #41801