mirror of
https://github.com/mudler/LocalAI.git
synced 2026-07-04 05:16:42 -04:00
7a3583b52c
Two bugs broke OpenAI-style tool calling on the MLX backend (and any
Python backend sharing backend/python/common), reproduced end-to-end on
LocalAI v4.5.5 with the metal-mlx backend and
mlx-community/Qwen3.5-2B-MLX-8bit.
messages_to_dicts left each tool call's function.arguments as the raw
OpenAI-wire JSON string. HuggingFace chat templates (e.g. Qwen3.5)
iterate arguments as a mapping (.items()), so any request whose history
contained a prior assistant tool_calls message failed with HTTP 500
"Generation failed: Can only get item pairs from a mapping." — breaking
every agent loop on its second turn. Decode the string back into a dict
so the template sees a mapping.
split_reasoning returned ("", text) whenever the opening think tag was
absent. Models like Qwen3.5 open the assistant turn already inside
thinking, so the generated text carries only the closing </think>; the
whole chain-of-thought leaked into content. When the opener is missing
but the closer is present, treat everything before the closer as
reasoning.
Adds platform-independent unit tests under backend/python/common
(stdlib-only, no MLX/venv required, following parent_watch_test.py).
Assisted-by: Claude Code:claude-opus-4-8
Co-authored-by: Ettore Di Giacinto <mudler@localai.io>
123 lines
4.2 KiB
Python
123 lines
4.2 KiB
Python
"""Unit tests for the shared python backend helpers (python_utils.py).
|
|
|
|
Run standalone (Python standard library only, no backend venv needed):
|
|
python3 -m unittest python_utils_test
|
|
|
|
These mirror the server-less helper tests in backend/python/mlx/test.py
|
|
(TestSharedHelpers), but live here so they run on any platform: the mlx
|
|
test module imports grpc/backend_pb2 at import time and needs the MLX venv,
|
|
whereas python_utils has no third-party dependency. Proto Message objects
|
|
are faked with types.SimpleNamespace (real proto fields default to "").
|
|
"""
|
|
|
|
import json
|
|
import types
|
|
import unittest
|
|
|
|
from python_utils import messages_to_dicts, parse_options
|
|
|
|
|
|
def _msg(**fields):
|
|
"""Fake a proto Message: every unset field is the empty string, as protobuf."""
|
|
defaults = {
|
|
"role": "",
|
|
"content": "",
|
|
"name": "",
|
|
"tool_call_id": "",
|
|
"reasoning_content": "",
|
|
"tool_calls": "",
|
|
}
|
|
defaults.update(fields)
|
|
return types.SimpleNamespace(**defaults)
|
|
|
|
|
|
class TestParseOptions(unittest.TestCase):
|
|
def test_type_inference(self):
|
|
opts = parse_options(
|
|
["temperature:0.7", "max_tokens:128", "trust:true", "name:hello", "no_colon_skipped"]
|
|
)
|
|
self.assertEqual(opts["temperature"], 0.7)
|
|
self.assertEqual(opts["max_tokens"], 128)
|
|
self.assertIs(opts["trust"], True)
|
|
self.assertEqual(opts["name"], "hello")
|
|
self.assertNotIn("no_colon_skipped", opts)
|
|
|
|
|
|
class TestMessagesToDicts(unittest.TestCase):
|
|
def test_basic_fields(self):
|
|
out = messages_to_dicts(
|
|
[
|
|
_msg(role="user", content="hi"),
|
|
_msg(role="tool", content="42", tool_call_id="call_1", name="f"),
|
|
]
|
|
)
|
|
self.assertEqual(out[0], {"role": "user", "content": "hi"})
|
|
self.assertEqual(out[1]["tool_call_id"], "call_1")
|
|
self.assertEqual(out[1]["name"], "f")
|
|
|
|
def test_tool_call_arguments_string_decoded_to_mapping(self):
|
|
# OpenAI wire format ships function.arguments as a JSON *string*; chat
|
|
# templates iterate it as a mapping, so it must come back as a dict.
|
|
out = messages_to_dicts(
|
|
[
|
|
_msg(
|
|
role="assistant",
|
|
tool_calls=json.dumps(
|
|
[
|
|
{
|
|
"id": "call_1",
|
|
"type": "function",
|
|
"function": {
|
|
"name": "get_weather",
|
|
"arguments": '{"location": "Rome"}',
|
|
},
|
|
}
|
|
]
|
|
),
|
|
)
|
|
]
|
|
)
|
|
args = out[0]["tool_calls"][0]["function"]["arguments"]
|
|
self.assertEqual(args, {"location": "Rome"})
|
|
self.assertEqual(dict(args.items()), {"location": "Rome"})
|
|
|
|
def test_tool_call_arguments_already_mapping_is_idempotent(self):
|
|
out = messages_to_dicts(
|
|
[
|
|
_msg(
|
|
role="assistant",
|
|
tool_calls=json.dumps(
|
|
[{"function": {"name": "f", "arguments": {"a": 1}}}]
|
|
),
|
|
)
|
|
]
|
|
)
|
|
self.assertEqual(out[0]["tool_calls"][0]["function"]["arguments"], {"a": 1})
|
|
|
|
def test_tool_call_arguments_invalid_json_left_as_string(self):
|
|
out = messages_to_dicts(
|
|
[
|
|
_msg(
|
|
role="assistant",
|
|
tool_calls=json.dumps(
|
|
[{"function": {"name": "f", "arguments": "not-json"}}]
|
|
),
|
|
)
|
|
]
|
|
)
|
|
self.assertEqual(out[0]["tool_calls"][0]["function"]["arguments"], "not-json")
|
|
|
|
def test_tool_call_without_function_key(self):
|
|
out = messages_to_dicts(
|
|
[_msg(role="assistant", tool_calls=json.dumps([{"id": "call_1"}]))]
|
|
)
|
|
self.assertEqual(out[0]["tool_calls"], [{"id": "call_1"}])
|
|
|
|
def test_tool_calls_invalid_json_dropped(self):
|
|
out = messages_to_dicts([_msg(role="assistant", tool_calls="{not json")])
|
|
self.assertNotIn("tool_calls", out[0])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|