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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
"""Parallel calls sharing one delta index are split at the end of each top-level JSON object."""
from __future__ import annotations
import json
import pytest
from core.inference.studio_tool_loop import (
_Turn,
_split_top_level_json_objects,
)
@pytest.mark.parametrize(
"text,complete,tail",
[
("", [], ""),
("{}", ["{}"], ""),
('{"a":1}', ['{"a":1}'], ""),
('{"a":1}{"b":2}', ['{"a":1}', '{"b":2}'], ""),
(
'{"a":1} {"b":2}\n{"c":3}\r\n{"d":4}',
['{"a":1}', '{"b":2}', '{"c":3}', '{"d":4}'],
"",
),
('{"a":', [], '{"a":'),
('{"a":1}{"b":', ['{"a":1}'], '{"b":'),
('{"a":"}{"}{"b":2}', ['{"a":"}{"}', '{"b":2}'], ""),
('{"a":"say \\"}{\\" ok"}{"b":2}', ['{"a":"say \\"}{\\" ok"}', '{"b":2}'], ""),
('{"p":"C:\\\\Users\\\\me"}{"b":2}', ['{"p":"C:\\\\Users\\\\me"}', '{"b":2}'], ""),
('{"a":{"b":{"c":1}}}', ['{"a":{"b":{"c":1}}}'], ""),
('{"a":[{"b":1},{"c":2}]}', ['{"a":[{"b":1},{"c":2}]}'], ""),
(
'{"q":"caf\u00e9 \u65e5\u672c\u8a9e \U0001f680"}',
['{"q":"caf\u00e9 \u65e5\u672c\u8a9e \U0001f680"}'],
"",
),
('[{"a":1}]', [], '[{"a":1}]'),
('"hello"', [], '"hello"'),
("42", [], "42"),
("null", [], "null"),
('{"a":1}junk{"b":2}', [], '{"a":1}junk{"b":2}'),
('{"a":1}}', [], '{"a":1}}'),
('{"a":1,}{"b":2}', [], '{"a":1,}{"b":2}'),
('{"a":"unterminated', [], '{"a":"unterminated'),
],
)
def test_split_top_level_json_objects(text, complete, tail):
assert _split_top_level_json_objects(text) == (complete, tail)
def _delta(
index,
name = None,
arguments = "",
call_id = None,
):
function: dict = {"arguments": arguments}
if name is not None:
function["name"] = name
call: dict = {"index": index, "function": function}
if call_id is not None:
call["id"] = call_id
return call
def _reported(turn: _Turn):
"""Slots that arrived with a name but no arguments are dropped here, not run."""
return [(call["function"]["name"], call["function"]["arguments"]) for call in turn.calls()]
def _shape(turn: _Turn):
return [
(turn.by_index[key]["function"]["name"], turn.by_index[key]["function"]["arguments"])
for key in turn.order
]
def test_the_stream_from_9807_becomes_one_call_per_object():
turn = _Turn()
turn.merge_structured([_delta(0, "url", '{"url":"a"}')])
turn.merge_structured([_delta(0, "url", '{"url":"b"}')])
turn.merge_structured([_delta(0, "query", '{"q":"c"}')])
turn.merge_structured([_delta(0, "url", '{"url":"d"}')])
assert _shape(turn) == [
("url", '{"url":"a"}'),
("url", '{"url":"b"}'),
("query", '{"q":"c"}'),
("url", '{"url":"d"}'),
]
for _name, arguments in _shape(turn):
assert isinstance(json.loads(arguments), dict)
def test_every_forked_call_gets_an_id_of_its_own():
turn = _Turn()
turn.merge_structured([_delta(0, "url", '{"url":"a"}{"url":"b"}')])
ids = [call["id"] for call in turn.calls()]
assert len(ids) == 2
assert len(set(ids)) == 2
assert all(ids)
def test_a_call_at_another_index_survives_a_fork():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(1, "beta", '{"b":2}')])
turn.merge_structured([_delta(0, "gamma", '{"c":3}')])
assert _shape(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}'), ("gamma", '{"c":3}')]
def test_an_ordinary_fragmented_call_is_still_one_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":')])
turn.merge_structured([_delta(0, None, "1")])
turn.merge_structured([_delta(0, None, "}")])
assert _shape(turn) == [("alpha", '{"a":1}')]
def test_a_fragment_continues_the_call_still_being_written():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}{"b":')])
turn.merge_structured([_delta(0, None, "2}")])
assert _shape(turn) == [("alpha", '{"a":1}'), ("alpha", '{"b":2}')]
def test_a_stream_that_carries_ids_forks_on_the_id_as_before():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":', call_id = "call_a")])
turn.merge_structured([_delta(1, "beta", '{"b":', call_id = "call_b")])
turn.merge_structured([_delta(0, None, "1}", call_id = "call_a")])
turn.merge_structured([_delta(1, None, "2}", call_id = "call_b")])
assert _shape(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
assert [call["id"] for call in turn.calls()] == ["call_a", "call_b"]
def test_a_name_arriving_in_fragments_is_unaffected():
# llama-server resends the whole name as it grows; OpenAI streams pieces.
turn = _Turn()
turn.merge_structured([_delta(0, "web", '{"q":')])
turn.merge_structured([_delta(0, "web_search", '"x"}')])
assert _shape(turn) == [("web_search", '{"q":"x"}')]
def test_a_name_only_delta_does_not_rename_the_finished_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "beta", "")])
turn.merge_structured([_delta(0, None, '{"b":2}')])
assert _shape(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
def test_an_id_after_one_closed_object_opens_a_call_not_a_claim():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "beta", '{"b":2}', call_id = "call_b")])
assert _shape(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
assert [call["id"] for call in turn.calls()] == ["call_0_0", "call_b"]
def test_an_id_after_a_closed_fork_opens_a_third_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}{"b":2}')])
turn.merge_structured([_delta(0, "gamma", '{"c":3}', call_id = "call_c")])
assert _shape(turn) == [("alpha", '{"a":1}'), ("alpha", '{"b":2}'), ("gamma", '{"c":3}')]
ids = [call["id"] for call in turn.calls()]
assert len(set(ids)) == len(ids)
def test_nesting_deep_enough_to_exhaust_the_stack_is_unsplittable():
payload = '{"x":' * 20000 + "null" + "}" * 20000
assert _split_top_level_json_objects(payload) == ([], payload)
turn = _Turn()
turn.merge_structured([_delta(0, "deep", payload)])
assert _shape(turn) == [("deep", payload)]
def test_a_fragment_repeating_the_slots_id_continues_that_call():
turn = _Turn()
turn.merge_structured([_delta(0, "web", '{"q":"x"}', call_id = "call_a")])
turn.merge_structured([_delta(0, "web_search", "", call_id = "call_a")])
assert _shape(turn) == [("web_search", '{"q":"x"}')]
assert [call["id"] for call in turn.calls()] == ["call_a"]
def test_whitespace_chunked_after_a_closing_brace_is_not_a_new_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "alpha", " ")])
assert _shape(turn) == [("alpha", '{"a":1} ')]
turn.merge_structured([_delta(0, "alpha", '{"b":2}')])
assert _shape(turn) == [("alpha", '{"a":1} '), ("alpha", '{"b":2}')]
def test_the_metadata_a_delta_carries_goes_to_the_call_it_closes():
# It belongs to the last object this delta closed; Gemini validates against that.
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":')])
turn.merge_structured(
[_delta(0, None, '1}{"b":2}') | {"extra_content": {"google": {"thought_signature": "SIG"}}}]
)
entries = [turn.by_index[key] for key in turn.order]
assert [e["function"]["arguments"] for e in entries] == ['{"a":1}', '{"b":2}']
assert entries[0].get("extra_content") is None
assert entries[1]["extra_content"] == {"google": {"thought_signature": "SIG"}}
def test_nonstandard_numeric_constants_are_not_object_boundaries():
# json.loads takes NaN and Infinity; JSON.parse does not.
assert _split_top_level_json_objects('{"a":NaN}{"b":2}') == ([], '{"a":NaN}{"b":2}')
assert _split_top_level_json_objects('{"a":Infinity}{"b":2}') == (
[],
'{"a":Infinity}{"b":2}',
)
assert _split_top_level_json_objects('{"a":1.5e3}{"b":2}') == (
['{"a":1.5e3}', '{"b":2}'],
"",
)
def test_an_opening_delta_after_a_closed_call_does_not_claim_it():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "beta", "", call_id = "call_b")])
turn.merge_structured([_delta(0, None, '{"b":2}', call_id = "call_b")])
assert _shape(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
ids = [call["id"] for call in turn.calls()]
assert ids[1] == "call_b"
assert len(set(ids)) == len(ids)
def test_a_name_held_for_the_next_call_grows_across_deltas():
for fragments in (("web", "_search"), ("web", "web_search")):
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
for fragment in fragments:
turn.merge_structured([_delta(0, fragment, "")])
turn.merge_structured([_delta(0, None, '{"q":"x"}')])
assert _shape(turn) == [("alpha", '{"a":1}'), ("web_search", '{"q":"x"}')]
def test_whitespace_carrying_the_repeated_name_is_not_the_next_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "alpha", " ")])
turn.merge_structured([_delta(0, "beta", '{"b":2}')])
assert _shape(turn) == [("alpha", '{"a":1} '), ("beta", '{"b":2}')]
def test_a_repeated_id_reaches_its_own_call_across_a_later_split():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}', call_id = "call_a")])
turn.merge_structured([_delta(0, "beta", '{"b":')])
turn.merge_structured([_delta(0, "alpha_long", "", call_id = "call_a")])
assert _shape(turn) == [("alpha_long", '{"a":1}'), ("beta", '{"b":')]
ids = [call["id"] for call in turn.calls()]
assert ids[0] == "call_a"
assert len(set(ids)) == len(ids)
def test_metadata_announced_with_a_name_waits_for_that_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured(
[_delta(0, "beta", None) | {"extra_content": {"google": {"thought_signature": "SIG"}}}]
)
turn.merge_structured([_delta(0, None, '{"b":2}')])
entries = [turn.by_index[key] for key in turn.order]
assert _shape(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
assert entries[0].get("extra_content") is None
assert entries[1]["extra_content"] == {"google": {"thought_signature": "SIG"}}
def test_the_resumable_scan_agrees_with_scanning_from_the_start():
import random
from core.inference.studio_tool_loop import _BoundaryScan
pieces = list('{}"\\ abc:,1[]') + ['\\"', '"a"', "NaN", "\n", "\r\n", "\t", '{"a":1}', "}{"]
rng = random.Random(20260827)
for _ in range(4000):
text = "".join(rng.choice(pieces) for _ in range(rng.randint(0, 16)))
scan = _BoundaryScan()
cut = 0
result = scan.feed("")
while cut < len(text):
cut = min(len(text), cut + rng.randint(1, 4))
result = scan.feed(text[:cut])
assert result == _split_top_level_json_objects(text), text
def test_one_argument_streamed_a_character_at_a_time_stays_linear():
# The bound is generous: it asserts the quadratic term, not machine speed.
import time
payload = '{"code":"' + "x" * 20000 + '"}'
turn = _Turn()
turn.merge_structured([_delta(0, "write", "")])
started = time.perf_counter()
for ch in payload:
turn.merge_structured([_delta(0, None, ch)])
assert time.perf_counter() - started < 2.0
assert _shape(turn) == [("write", payload)]
def test_metadata_arriving_alone_stays_on_the_call_that_closed():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([{"index": 0, "extra_content": {"google": {"thought_signature": "SIG"}}}])
assert _shape(turn) == [("alpha", '{"a":1}')]
entries = [turn.by_index[key] for key in turn.order]
assert entries[0]["extra_content"] == {"google": {"thought_signature": "SIG"}}
def test_a_call_announced_by_name_only_is_still_reported():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "beta", "")])
reported = [(call["function"]["name"], call["function"]["arguments"]) for call in turn.calls()]
assert reported == [("alpha", '{"a":1}'), ("beta", "{}")]
ids = [call["id"] for call in turn.calls()]
assert len(set(ids)) == len(ids)
turn.merge_structured([_delta(0, None, '{"b":2}')])
assert _shape(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
def test_a_name_resent_or_grown_after_a_call_closed_invents_nothing():
for resent in ("alpha", "alpha_long"):
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, resent, "")])
reported = [
(call["function"]["name"], call["function"]["arguments"]) for call in turn.calls()
]
assert reported == [("alpha", '{"a":1}')]
def test_a_pending_call_runs_where_the_stream_announced_it():
turn = _Turn()
turn.merge_structured([_delta(0, "A", '{"a":1}')])
turn.merge_structured([_delta(0, "B", "")])
turn.merge_structured([_delta(1, "C", '{"c":3}')])
reported = [(call["function"]["name"], call["function"]["arguments"]) for call in turn.calls()]
assert reported == [("A", '{"a":1}'), ("B", "{}"), ("C", '{"c":3}')]
def test_a_fragment_that_does_not_open_an_object_does_not_open_a_call():
turn = _Turn()
turn.merge_structured([_delta(0, "q", '{"query":"a"}')])
turn.merge_structured([_delta(0, "q", '"b"')])
assert _shape(turn) == [("q", '{"query":"a"}"b"')]
assert _split_top_level_json_objects('{"query":"a"}"b"') == ([], '{"query":"a"}"b"')
def test_an_integer_too_long_to_convert_is_still_a_boundary():
# json.loads raises past the 4300-digit int cap; JSON.parse does not, so keep them text.
big = '{"a":' + "1" * 4301 + "}"
assert _split_top_level_json_objects(big + '{"b":2}') == ([big, '{"b":2}'], "")
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", big)])
turn.merge_structured([_delta(0, "beta", '{"b":2}')])
assert _shape(turn) == [("alpha", big), ("beta", '{"b":2}')]
def test_two_calls_announced_at_once_do_not_break_the_sort():
# Ties broken by comparing the calls themselves raise TypeError.
turn = _Turn()
turn.merge_structured([_delta(0, "A", '{"a":1}')])
turn.merge_structured([_delta(1, "B", '{"b":1}')])
turn.merge_structured([_delta(0, "C", "")])
turn.merge_structured([_delta(1, "D", "")])
reported = [(call["function"]["name"], call["function"]["arguments"]) for call in turn.calls()]
assert reported == [("A", '{"a":1}'), ("B", '{"b":1}'), ("C", "{}"), ("D", "{}")]
def test_a_pending_call_keeps_its_place_when_it_later_opens():
turn = _Turn()
turn.merge_structured([_delta(0, "A", '{"a":1}')])
turn.merge_structured([_delta(0, "B", "")])
turn.merge_structured([_delta(1, "C", '{"c":3}')])
turn.merge_structured([_delta(0, None, '{"b":2}')])
reported = [(call["function"]["name"], call["function"]["arguments"]) for call in turn.calls()]
assert reported == [("A", '{"a":1}'), ("B", '{"b":2}'), ("C", '{"c":3}')]
def test_a_resent_name_does_not_rename_the_call_it_closed():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "alpha_long", "")])
turn.merge_structured([_delta(0, "beta", '{"b":2}')])
assert _reported(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
same = _Turn()
same.merge_structured([_delta(0, "no_args", "{}")])
same.merge_structured([_delta(0, "no_args", "")])
same.merge_structured([_delta(0, None, "{}")])
assert _reported(same) == [("no_args", "{}"), ("no_args", "{}")]
grown = _Turn()
grown.merge_structured([_delta(0, "alpha", '{"a":1}')])
grown.merge_structured([_delta(0, "web", "")])
grown.merge_structured([_delta(0, "_search", '{"q":1}')])
assert _reported(grown) == [("alpha", '{"a":1}'), ("web_search", '{"q":1}')]
def test_metadata_on_a_resent_name_stays_with_the_closed_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}') | {"extra_content": {"own": "A"}}])
turn.merge_structured([_delta(0, "alpha_long", None) | {"extra_content": {"resent": 1}}])
turn.merge_structured([_delta(0, "beta", '{"b":2}')])
reported = turn.calls()
assert _reported(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
assert reported[0]["extra_content"] == {"own": "A", "resent": 1}
assert reported[1].get("extra_content") is None
def test_a_discarded_resend_does_not_lend_its_place_to_the_next_call():
turn = _Turn()
turn.merge_structured([_delta(0, "A", '{"a":1}')])
turn.merge_structured([_delta(0, "A_long", None)])
turn.merge_structured([_delta(1, "C", '{"c":3}')])
turn.merge_structured([_delta(0, "B", '{"b":2}')])
assert [call["function"]["name"] for call in turn.calls()] == ["A", "C", "B"]
kept = _Turn()
kept.merge_structured([_delta(0, "A", '{"a":1}')])
kept.merge_structured([_delta(0, "B", None)])
kept.merge_structured([_delta(1, "C", '{"c":3}')])
kept.merge_structured([_delta(0, None, '{"b":2}')])
assert [call["function"]["name"] for call in kept.calls()] == ["A", "B", "C"]
def test_an_id_stamped_after_the_object_closed_claims_that_call():
for late in ({}, {"name": "alpha"}):
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([{"index": 0, "id": "call_a", "function": late}])
reported = [
(call["id"], call["function"]["name"], call["function"]["arguments"])
for call in turn.calls()
]
assert reported == [("call_a", "alpha", '{"a":1}')]
opened = _Turn()
opened.merge_structured([_delta(0, "alpha", '{"a":1}')])
opened.merge_structured([_delta(0, "beta", "", call_id = "call_b")])
opened.merge_structured([_delta(0, None, '{"b":2}', call_id = "call_b")])
assert _shape(opened) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
def test_a_new_name_arriving_with_whitespace_opens_its_own_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "beta", " ")])
turn.merge_structured([_delta(0, None, '{"b":2}')])
assert _shape(turn) == [("alpha", '{"a":1}'), ("beta", ' {"b":2}')]
resent = _Turn()
resent.merge_structured([_delta(0, "alpha", '{"a":1}')])
resent.merge_structured([_delta(0, "alpha", " ")])
resent.merge_structured([_delta(0, "beta", '{"b":2}')])
assert _shape(resent) == [("alpha", '{"a":1} '), ("beta", '{"b":2}')]
def test_metadata_on_a_resent_name_reaches_the_closed_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}') | {"extra_content": {"own": "A"}}])
turn.merge_structured([_delta(0, "alpha_long", None) | {"extra_content": {"sig": "S"}}])
reported = turn.calls()
assert [(c["function"]["name"], c["function"]["arguments"]) for c in reported] == [
("alpha", '{"a":1}')
]
assert reported[0]["extra_content"] == {"own": "A", "sig": "S"}
assert turn.calls()[0]["extra_content"] == {"own": "A", "sig": "S"}
def test_a_catalog_holding_both_web_and_web_search_splits_either_way_round():
for first, second in (("web_search", "web"), ("web", "web_search")):
turn = _Turn()
turn.merge_structured([_delta(0, first, '{"a":1}')])
turn.merge_structured([_delta(0, second)])
turn.merge_structured([_delta(0, None, '{"b":2}')])
assert _reported(turn) == [(first, '{"a":1}'), (second, '{"b":2}')]
def test_a_name_bringing_an_object_over_an_announcement_is_the_next_call():
for announced in ("alpha_long", "zeta"):
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, announced, None)])
turn.merge_structured([_delta(0, "beta", '{"b":2}')])
assert _reported(turn) == [("alpha", '{"a":1}'), ("beta", '{"b":2}')]
def test_an_unfinished_fork_does_not_reserve_a_card_id():
taken: set[str] = set()
cards: set[str] = set()
first = _Turn()
first.merge_structured([_delta(0, "alpha", '{"a":1}{')])
assert [call.get("card_id") for call in first.calls(taken, cards)] == ["tool_call_0"]
second = _Turn()
second.round = 1
second.merge_structured([_delta(0, "beta", '{"b":2}')])
assert [call.get("card_id") for call in second.calls(taken, cards)] == ["tool_call_1"]
def test_a_provider_claiming_a_minted_id_displaces_the_id_less_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(1, "beta", '{"b":2}', call_id = "tool_call_0")])
reported = [
(call.get("card_id") or call["id"], call["function"]["name"]) for call in turn.calls()
]
assert reported == [("tool_call_1", "alpha"), ("tool_call_0", "beta")]
def test_a_claim_on_a_split_born_card_leaves_every_call_its_own():
# The client renumbers minted cards when a provider claims a spelling: expect 0, 2, 3.
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}{"b":2}{"c":3}')])
turn.merge_structured([_delta(1, "beta", '{"d":4}', call_id = "tool_call_1")])
reported = [
(call.get("card_id") or call["id"], call["function"]["arguments"]) for call in turn.calls()
]
assert reported == [
("tool_call_0", '{"a":1}'),
("tool_call_2", '{"b":2}'),
("tool_call_3", '{"c":3}'),
("tool_call_1", '{"d":4}'),
]
def test_a_nameless_call_reserves_no_card_id():
taken: set[str] = set()
cards: set[str] = set()
first = _Turn()
first.merge_structured([_delta(0, None, '{"a":1}')])
assert first.calls(taken, cards) == []
second = _Turn()
second.round = 1
second.merge_structured([_delta(0, "beta", '{"b":2}')])
assert [call.get("card_id") for call in second.calls(taken, cards)] == ["tool_call_0"]
def test_a_card_ledger_is_append_only_across_rounds():
taken: set[str] = set()
cards: set[str] = set()
first = _Turn()
first.merge_structured([_delta(0, "alpha", '{"a":1}')])
assert [call.get("card_id") for call in first.calls(taken, cards)] == ["tool_call_0"]
second = _Turn()
second.round = 1
second.merge_structured([_delta(0, "beta", '{"b":2}', call_id = "tool_call_0")])
assert [call.get("card_id") for call in second.calls(taken, cards)] == [None]
third = _Turn()
third.round = 2
third.merge_structured([_delta(0, "gamma", '{"c":3}')])
assert [call.get("card_id") for call in third.calls(taken, cards)] == ["tool_call_1"]
def test_a_rejected_call_reserves_no_card_id():
taken: set[str] = set()
cards: set[str] = set()
first = _Turn()
first.merge_structured([_delta(0, None, '{"a":1}', call_id = "tool_call_0")])
first.merge_structured([_delta(1, "beta", '{"b":2}')])
assert [call.get("card_id") for call in first.calls(taken, cards)] == ["tool_call_1"]
second = _Turn()
second.round = 1
second.merge_structured([_delta(0, "gamma", '{"c":3}')])
assert [call.get("card_id") for call in second.calls(taken, cards)] == ["tool_call_0"]
def test_a_nameless_claim_does_not_take_a_valid_call_s_card():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(1, None, '{"b":2}', call_id = "tool_call_0")])
reported = [(call.get("card_id"), call["function"]["name"]) for call in turn.calls()]
assert reported == [("tool_call_0", "alpha")]
def test_a_repeated_names_metadata_waits_for_the_call_it_announced():
turn = _Turn()
turn.merge_structured([_delta(0, "lookup", '{"q":"a"}') | {"extra_content": {"sig": "A"}}])
turn.merge_structured([_delta(0, "lookup", None) | {"extra_content": {"sig": "B"}}])
turn.merge_structured([_delta(0, None, '{"q":"b"}')])
reported = turn.calls()
assert _reported(turn) == [("lookup", '{"q":"a"}'), ("lookup", '{"q":"b"}')]
assert reported[0]["extra_content"] == {"sig": "A"}
assert reported[1]["extra_content"] == {"sig": "B"}
kept = _Turn()
kept.merge_structured([_delta(0, "lookup", '{"q":"a"}') | {"extra_content": {"own": 1}}])
kept.merge_structured([_delta(0, "lookup", None) | {"extra_content": {"sig": "B"}}])
assert kept.calls()[0]["extra_content"] == {"own": 1, "sig": "B"}
def test_parked_metadata_survives_a_late_id_landing_on_the_call():
# Pinned: the frontend keys the same wait by card id, which a late id renames.
turn = _Turn()
turn.merge_structured([_delta(0, "lookup", '{"q":"a"}') | {"extra_content": {"sig": "A"}}])
turn.merge_structured([_delta(0, "lookup", None) | {"extra_content": {"sig": "B"}}])
turn.merge_structured([_delta(0, None, "") | {"id": "call_x"}])
reported = turn.calls()
assert _reported(turn) == [("lookup", '{"q":"a"}')]
assert reported[0]["extra_content"] == {"sig": "B"}
def test_a_stable_id_naming_a_longer_tool_opens_its_own_call():
turn = _Turn()
turn.merge_structured([_delta(0, "web", '{"a":1}')])
turn.merge_structured([_delta(0, "web_search", "", call_id = "call_b")])
turn.merge_structured([_delta(0, None, '{"b":2}', call_id = "call_b")])
reported = [
(call["id"], call["function"]["name"], call["function"]["arguments"])
for call in turn.calls()
]
assert reported == [("call_0_0", "web", '{"a":1}'), ("call_b", "web_search", '{"b":2}')]
def test_an_unfinished_split_tail_is_not_reported_as_a_call():
# Nothing marks this truncated; running the tool on half an argument is worse.
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}{')])
assert [(call["function"]["name"], call["function"]["arguments"]) for call in turn.calls()] == [
("alpha", '{"a":1}')
]
turn.merge_structured([_delta(0, None, '"b":2}')])
assert _shape(turn) == [("alpha", '{"a":1}'), ("alpha", '{"b":2}')]
def test_a_second_call_to_the_same_tool_keeps_that_tools_name():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, None, '{"a":2}')])
assert _shape(turn) == [("alpha", '{"a":1}'), ("alpha", '{"a":2}')]
def test_a_snapshot_repeated_to_carry_the_id_claims_the_call():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "alpha", '{"a":1}', call_id = "call_a")])
reported = [
(call["id"], call["function"]["name"], call["function"]["arguments"])
for call in turn.calls()
]
assert reported == [("call_a", "alpha", '{"a":1}')]
def test_a_second_call_that_differs_anywhere_still_opens_its_own():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
turn.merge_structured([_delta(0, "alpha", '{"a":2}', call_id = "call_b")])
reported = [(call["id"], call["function"]["arguments"]) for call in turn.calls()]
assert reported == [("call_0_0", '{"a":1}'), ("call_b", '{"a":2}')]
def test_an_id_less_call_carries_the_card_id_the_client_painted():
turn = _Turn()
for url in ("a", "b", "c", "d"):
turn.merge_structured([_delta(0, "fetch", '{"url":"%s"}' % url)])
reported = [(call["id"], call.get("card_id")) for call in turn.calls()]
assert reported == [
("call_0_0", "tool_call_0"),
("call_0_1", "tool_call_1"),
("call_0_2", "tool_call_2"),
("call_0_3", "tool_call_3"),
]
def test_the_conversation_id_is_not_the_card_id():
# Stored ids stay call_<round>_<position> so older threads still resolve.
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}')])
call = turn.calls()[0]
assert call["id"] == "call_0_0"
assert call["card_id"] == "tool_call_0"
def test_a_call_the_provider_named_gets_no_card_id():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}', call_id = "call_a")])
call = turn.calls()[0]
assert call["id"] == "call_a"
assert "card_id" not in call
def test_a_second_round_keeps_numbering_where_the_first_stopped():
# One list of cards spans the response; restarting at tool_call_0 would hit round one's cards.
first = _Turn()
first.merge_structured([_delta(0, "alpha", '{"a":1}')])
painted: set[str] = set()
taken: set[str] = set()
assert [call["card_id"] for call in first.calls(taken, painted)] == ["tool_call_0"]
second = _Turn()
second.round = 1
second.merge_structured([_delta(0, "beta", '{"b":2}')])
assert [call["card_id"] for call in second.calls(taken, painted)] == ["tool_call_1"]
def test_a_provider_id_in_the_minted_namespace_is_not_handed_out_twice():
turn = _Turn()
turn.merge_structured([_delta(0, "alpha", '{"a":1}', call_id = "tool_call_0")])
turn.merge_structured([_delta(1, "beta", '{"b":2}')])
reported = [(call["id"], call.get("card_id")) for call in turn.calls()]
assert reported == [("tool_call_0", None), ("call_0_1", "tool_call_1")]
def test_a_slot_that_opens_late_keeps_its_own_index():
turn = _Turn()
turn.merge_structured([_delta(3, "alpha", '{"a":1}')])
assert [call.get("card_id") for call in turn.calls()] == ["tool_call_3"]