fix(common): more robust JSON string loading

[opposj]

AgentScope Version

1.0.17

Description

I encountered a JSON parsing issue while working with a locally deployed vLLM model fine-tuned on the Qwen-3 series. With tool calls resolved by Hermes, I obtained the following function argument (take an example):

args = '"{\\"query\\": \\"weak value amplification second order expansion average meter observable\\"}"' 

Currently, the JSON parsing in

agentscope/src/agentscope/_utils/_common.py

Line 31 in c19b8bc

def _json_loads_with_repair(

acts in a once-to-pass scheme, resulting in:

json.loads('"{\\"query\\": \\"weak value amplification second order expansion average meter observable\\"}"')
# -> '{"query": "weak value amplification second order expansion average meter observable"}'

Still a string and fails the isinstance check. However, it can actually be parsed via json.loads again:

json.loads('{"query": "weak value amplification second order expansion average meter observable"}')
# -> {'query': 'weak value amplification second order expansion average meter observable'}

Based on this observation, it is more robust to iteratively parse the raw string until a dict check is satisfied, and that's all about this commit. This commit is fully backward compatible and does not affect any other components, just providing a more robust JSON string parsing.

Checklist

Please check the following items before code is ready to be reviewed.

• Code has been formatted with pre-commit run --all-files command
• All tests are passing
• Docstrings are in Google style
• Related documentation has been updated (e.g. links, examples, etc.)
• Code is ready for review

[DavdGao]

@opposj This introduces an infinite loop — the loop body is ... (no-op), so if json.loads(result) never returns a dict, it will loop forever. What's the intention here?

[opposj]

Actually, an infinite loop is technically impossible due to the "reduction" behavior of json.loads. Given any object, json.loads will never return itself unchanged. A possible type from dict[str, Any] | list[Any] | str | float | int | bool | None is always guaranteed, or an exception is raised. For any return type that is not a dict or str, when fed into json.loads again, an exception occurs, and we have captured it correctly. For str, as mentioned before, json.loads will never infinitely resolve a string; every time a string is fed, the output is shortened until an exception is hit. Overall, as our goal is to return a valid dict, iteratively checking for a potentially "nested" string is a more robust method with no risk introduced :)

I have added a simple example that demonstrates this "nested" case in the comment of the changed code.