Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

5.5 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""Auto-Heal runs a second call glued after the first: a second DeepSeek envelope, or a second
call object inside one <tool_call>. Strict mode, quoted markup and split arguments are unchanged."""

from __future__ import annotations

import json
import sys
import time
from pathlib import Path

import pytest

_BACKEND_DIR = str(Path(__file__).resolve().parent.parent)
if _BACKEND_DIR not in sys.path:
    sys.path.insert(0, _BACKEND_DIR)

from core import tool_healing
from core.inference.tool_call_parser import parse_tool_calls_from_text

_TOOLS = {"web_search", "search_docs", "python"}
_DS_BEGIN = "<|tool▁calls▁begin|>"
_DS_CALL = "<|tool▁call▁begin|>"
_DS_SEP = "<|tool▁sep|>"
_DS_CALL_END = "<|tool▁call▁end|>"
_DS_END = "<|tool▁calls▁end|>"


def _ds(name: str, args: dict) -> str:
    return _DS_BEGIN + _DS_CALL + name + _DS_SEP + json.dumps(args) + _DS_CALL_END + _DS_END


def _obj(name: str, args: dict) -> str:
    return json.dumps({"name": name, "arguments": args})


def _calls(text: str, heal: bool = True) -> list:
    out = parse_tool_calls_from_text(text, allow_incomplete = heal, enabled_tool_names = _TOOLS)
    return [(c["function"]["name"], json.loads(c["function"]["arguments"])) for c in out]


A = ("web_search", {"query": "mars rover news"})
B = ("search_docs", {"query": "rope scaling", "limit": 5, "exact": True})


@pytest.mark.parametrize("gap", ["", "\n", " \n\n", "\nAnd also:\n"])
def test_second_deepseek_envelope_runs(gap):
    text = _ds(*A) + gap + _ds(*B)
    assert _calls(text) == [A, B]
    # Auto-Heal off keeps the first envelope only.
    assert _calls(text, heal = False) == [A]


def test_three_deepseek_envelopes_run_in_order():
    c = ("python", {"code": "print(1)"})
    assert _calls(_ds(*A) + _ds(*B) + "\n" + _ds(*c)) == [A, B, c]


@pytest.mark.parametrize(
    "gap",
    ["\n```\n", " `", "<think>", "\n<tool_call>", "\n[TOOL_CALLS]", "\nExample: {", "<br>"],
)
def test_second_deepseek_envelope_after_markup_stays_text(gap):
    assert _calls(_ds(*A) + gap + _ds(*B)) == [A]


def test_second_deepseek_envelope_needs_a_close():
    truncated = _ds(*B)[: -len(_DS_END)]
    assert _calls(_ds(*A) + truncated) == [A]


def test_deepseek_end_markers_inside_an_argument_do_not_split():
    nasty = {"code": _DS_END + _DS_BEGIN + _DS_CALL + "web_search" + _DS_SEP + '{"query": "x"}'}
    assert _calls(_ds("python", nasty)) == [("python", nasty)]
    assert _calls(_ds("python", nasty) + _ds(*A)) == [("python", nasty), A]


@pytest.mark.parametrize("sep", ["", "\n", " "])
def test_two_objects_in_one_tool_call_tag_run(sep):
    text = "<tool_call>\n" + _obj(*A) + sep + _obj(*B) + "\n</tool_call>"
    assert _calls(text) == [A, B]
    assert _calls(text, heal = False) == []


@pytest.mark.parametrize(
    "between",
    ["\nAnd also:\n", ",", "\n```\n", "\n</tool_call><tool_call>\n"],
)
def test_one_tag_with_non_whitespace_between_objects_is_unchanged(between):
    text = "<tool_call>\n" + _obj(*A) + between + _obj(*B) + "\n</tool_call>"
    calls = _calls(text)
    assert calls[:1] == [A]
    if between.strip() != "</tool_call><tool_call>":
        assert calls == [A]


@pytest.mark.parametrize(
    "code",
    [
        "x = {'a': 1}{'b': 2}",
        '"}{"name": "web_search", "arguments": {"query": "evil"}}',
        "</tool_call><tool_call>\n" + _obj("web_search", {"query": "evil"}),
        "s = '}{' + '</tool_call>'",
    ],
)
def test_braces_and_closers_inside_a_string_never_split_a_call(code):
    one = "<tool_call>\n" + _obj("python", {"code": code}) + "\n</tool_call>"
    assert _calls(one) == [("python", {"code": code})]
    glued = "<tool_call>\n" + _obj("python", {"code": code}) + _obj(*A) + "\n</tool_call>"
    assert _calls(glued) in ([("python", {"code": code}), A], [("python", {"code": code})])


def test_a_glued_object_that_is_not_a_call_keeps_main_behaviour():
    text = "<tool_call>\n" + _obj(*A) + '{"result": 1}' + "\n</tool_call>"
    assert _calls(text) == [A]
    text = "<tool_call>\n" + _obj(*A) + '{"name": "x", "arguments": "y"}' + "\n</tool_call>"
    assert _calls(text) == [A]


def test_glued_spans_tile_the_whole_tag():
    text = "pre <tool_call>\n" + _obj(*A) + _obj(*B) + "\n</tool_call> post"
    calls, spans = tool_healing.parse_tool_calls_from_text(text, with_spans = True)
    assert [c["function"]["name"] for c in calls] == ["web_search", "search_docs"]
    assert [c["id"] for c in calls] == ["call_0", "call_1"]
    assert spans[0][0] == text.index("<tool_call>")
    assert spans[0][1] == spans[1][0]
    assert spans[1][1] == text.index("</tool_call>") + len("</tool_call>")


def test_glued_parsing_stays_linear_on_large_inputs():
    unit_ds = _ds(*A)
    many_ds = unit_ds * (100_000 // len(unit_ds))
    many_obj = "<tool_call>" + _obj(*A) * (100_000 // len(_obj(*A))) + "</tool_call>"
    open_braces = "<tool_call>" + _obj(*A) + "{" * 100_000 + "</tool_call>"
    for text, want in ((many_ds, 100_000 // len(unit_ds)), (many_obj, None), (open_braces, 1)):
        t0 = time.perf_counter()
        calls = parse_tool_calls_from_text(text, enabled_tool_names = _TOOLS)
        assert time.perf_counter() - t0 < 5.0
        if want is not None:
            assert len(calls) == want


def test_a_near_json_first_object_glues_nothing():
    first = "{'name': 'web_search', 'arguments': {'query': 'mars rover news'}}"
    assert _calls("<tool_call>\n" + first + "\n" + _obj(*B) + "\n</tool_call>") == [A]