e1fdb140b4
Two follow-ups on the streaming and tool-parse paths: - _anthropic_tool_stream and _anthropic_plain_stream drove generation through asyncio.to_thread(next, gen, ...) and only polled is_disconnected() between events, so a client disconnect during prefill or a long generation/tool step held the decode slot until the next event or a failed send. Both now run the _await_disconnect_then_cancel watcher used by the other local streams, stop it in finally, and break promptly when cancel_event is set. - _GEMMA_NEXT_KEY_RE treated any comma followed by word-chars-then-colon as the next key, so a bare value such as "meet at 10:00, 11:00 tomorrow" was split into bogus keys. The next-key token must now be identifier-shaped (start with a letter or underscore), so a comma before a timestamp, ratio, or other numeric-then-colon text stays part of the value. Adds a timestamp-in-bare-value regression test.
154 lines
6.2 KiB
Python
154 lines
6.2 KiB
Python
# SPDX-License-Identifier: AGPL-3.0-only
|
|
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
|
|
|
|
"""Edge cases in Gemma-native tool-call parsing.
|
|
|
|
Covers two failure modes:
|
|
1. A bare (unquoted) string argument that contains a comma, e.g.
|
|
``location:New York, NY`` -- the comma must not be treated as the next
|
|
key boundary, or the whole call is dropped.
|
|
2. A tool-call marker that appears INSIDE another call's argument string is
|
|
data, not a real call, so it must not be promoted to a second tool call.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
_BACKEND_DIR = str(Path(__file__).resolve().parent.parent)
|
|
if _BACKEND_DIR not in sys.path:
|
|
sys.path.insert(0, _BACKEND_DIR)
|
|
|
|
from core.inference.tool_call_parser import parse_tool_calls_from_text
|
|
|
|
|
|
def _args(call: dict) -> dict:
|
|
return json.loads(call["function"]["arguments"])
|
|
|
|
|
|
def test_bare_string_argument_with_comma_is_kept():
|
|
calls = parse_tool_calls_from_text(
|
|
"<|tool_call>call:get_weather{location:New York, NY,unit:celsius}<tool_call|>"
|
|
)
|
|
assert len(calls) == 1, calls
|
|
assert calls[0]["function"]["name"] == "get_weather"
|
|
assert _args(calls[0]) == {"location": "New York, NY", "unit": "celsius"}
|
|
|
|
|
|
def test_normal_multi_key_arguments_still_split():
|
|
calls = parse_tool_calls_from_text('<|tool_call>call:f{a:1,b:hello,c:"x,y"}<tool_call|>')
|
|
assert len(calls) == 1, calls
|
|
# Numbers stay numeric, bare strings get quoted, an explicit quoted comma
|
|
# stays inside its value.
|
|
assert _args(calls[0]) == {"a": 1, "b": "hello", "c": "x,y"}
|
|
|
|
|
|
def test_bare_value_with_timestamps_after_comma_is_kept():
|
|
# A comma followed by digits-then-colon (a timestamp/ratio) is value text,
|
|
# not a new key, so the whole query must be preserved as one argument.
|
|
calls = parse_tool_calls_from_text(
|
|
"<|tool_call>call:remind{query:meet at 10:00, 11:00 tomorrow,priority:high}<tool_call|>"
|
|
)
|
|
assert len(calls) == 1, calls
|
|
assert _args(calls[0]) == {
|
|
"query": "meet at 10:00, 11:00 tomorrow",
|
|
"priority": "high",
|
|
}
|
|
|
|
|
|
def test_marker_inside_json_argument_is_not_a_second_call():
|
|
# A python call whose `code` argument contains a Gemma marker string. The
|
|
# marker is data and must not execute as a second `terminal` call.
|
|
content = (
|
|
'<tool_call>{"name":"python","arguments":{"code":'
|
|
'"x = 1 # <|tool_call>call:terminal{command:ls}<tool_call|>"}}</tool_call>'
|
|
)
|
|
calls = parse_tool_calls_from_text(content)
|
|
assert [c["function"]["name"] for c in calls] == ["python"], calls
|
|
|
|
|
|
def test_two_separate_gemma_calls_both_parse():
|
|
content = "<|tool_call>call:a{x:1}<tool_call|> and <|tool_call>call:b{y:2}<tool_call|>"
|
|
calls = parse_tool_calls_from_text(content)
|
|
assert [c["function"]["name"] for c in calls] == ["a", "b"], calls
|
|
assert _args(calls[0]) == {"x": 1}
|
|
assert _args(calls[1]) == {"y": 2}
|
|
|
|
|
|
def test_mixed_format_calls_preserve_document_order():
|
|
# A Gemma-native call precedes a JSON-format call in the text; tools execute
|
|
# in returned order, so `create` must come before `read`.
|
|
content = (
|
|
"<|tool_call>call:create{path:a}<tool_call|> then "
|
|
'<tool_call>{"name":"read","arguments":{"path":"a"}}</tool_call>'
|
|
)
|
|
calls = parse_tool_calls_from_text(content)
|
|
assert [c["function"]["name"] for c in calls] == ["create", "read"], calls
|
|
|
|
|
|
def test_json_marker_inside_gemma_argument_is_not_a_second_call():
|
|
# The reverse of the JSON-outer case: a JSON-style marker inside a Gemma
|
|
# call's quoted argument is code text, not a second `terminal` call.
|
|
content = (
|
|
'<|tool_call>call:python{code:<|"|>'
|
|
'print(<tool_call>{"name":"terminal","arguments":{"command":"ls"}}</tool_call>)'
|
|
'<|"|>}<tool_call|>'
|
|
)
|
|
calls = parse_tool_calls_from_text(content)
|
|
assert [c["function"]["name"] for c in calls] == ["python"], calls
|
|
|
|
|
|
def test_bare_string_array_argument_is_quoted():
|
|
# Gemma may emit an array of bare strings without per-element quotes; they
|
|
# must be quoted so the call is not dropped.
|
|
calls = parse_tool_calls_from_text("<|tool_call>call:label{labels:[bug,ui]}<tool_call|>")
|
|
assert len(calls) == 1, calls
|
|
assert _args(calls[0]) == {"labels": ["bug", "ui"]}
|
|
|
|
|
|
def test_array_keeps_numbers_and_quoted_elements():
|
|
calls = parse_tool_calls_from_text(
|
|
'<|tool_call>call:f{nums:[1,2],tags:[<|"|>a,b<|"|>,c]}<tool_call|>'
|
|
)
|
|
assert _args(calls[0]) == {"nums": [1, 2], "tags": ["a,b", "c"]}
|
|
|
|
|
|
def test_array_of_objects_is_normalised():
|
|
# Arrays of objects are a common tool-schema shape; their (unquoted) keys and
|
|
# bare values must be normalised too, not left verbatim, or the call drops.
|
|
calls = parse_tool_calls_from_text(
|
|
"<|tool_call>call:batch{items:[{path:a,mode:r},{path:b,mode:w}]}<tool_call|>"
|
|
)
|
|
assert len(calls) == 1, calls
|
|
assert _args(calls[0]) == {"items": [{"path": "a", "mode": "r"}, {"path": "b", "mode": "w"}]}
|
|
|
|
|
|
def test_nested_array_elements_are_normalised():
|
|
calls = parse_tool_calls_from_text("<|tool_call>call:grid{cells:[[a,b],[c,d]]}<tool_call|>")
|
|
assert _args(calls[0]) == {"cells": [["a", "b"], ["c", "d"]]}
|
|
|
|
|
|
def test_gemma_marker_inside_xml_parameter_is_not_a_second_call():
|
|
# An XML-style <function=...> call whose <parameter=code> value contains a
|
|
# Gemma marker: the marker is the parameter's data, not a separate terminal
|
|
# call, so only the python call must be returned.
|
|
content = (
|
|
"<tool_call><function=python><parameter=code>"
|
|
"x = 1 # <|tool_call>call:terminal{command:ls}<tool_call|>"
|
|
"</parameter></function></tool_call>"
|
|
)
|
|
calls = parse_tool_calls_from_text(content)
|
|
assert [c["function"]["name"] for c in calls] == ["python"], calls
|
|
assert "terminal" in _args(calls[0])["code"]
|
|
|
|
|
|
def test_json_marker_inside_xml_parameter_is_not_a_second_call():
|
|
content = (
|
|
"<tool_call><function=python><parameter=code>"
|
|
'run(<tool_call>{"name":"terminal","arguments":{"command":"ls"}}</tool_call>)'
|
|
"</parameter></function></tool_call>"
|
|
)
|
|
calls = parse_tool_calls_from_text(content)
|
|
assert [c["function"]["name"] for c in calls] == ["python"], calls
|