fix(api): recover Qwen tool calls on ZeroGPU

The XML/think regexes required literal spaces around the tags, but Qwen
emits newlines, so agentic calls were dropped and returned as plain text
with finish_reason=stop. llama-cpp native message.tool_calls were also
ignored because only message.content was parsed.

Match arbitrary whitespace in both tool_call formats, split reasoning on
the bare closing tag, and prefer structured native tool calls, converting
arguments back to JSON strings. Adds regression tests for both paths.

app.py

@@ -697,8 +697,15 @@ def parse_model_tool_calls(text: str):
     tool_calls = []
     clean_text = text
 
-    # Pattern 1: Qwen XML style  <tool_call> <function=name> <parameter=k>v</parameter> </function> </tool_call>
-    xml_matches = list(re.finditer(r' <tool_call> <function=([a-zA-Z0-9_\-\.\:\/]+)>(.*?)</function>\s*</tool_call>', clean_text, re.DOTALL))
+    # Pattern 1: Qwen XML style <tool_call><function=name><parameter=k>v</parameter></function></tool_call>.
+    # Do not require spaces around the tags.  Qwen templates normally emit
+    # newlines (or no whitespace at all), while the original expression only
+    # matched a very specific, space-padded variant.
+    xml_matches = list(re.finditer(
+        r'\s*<tool_call>\s*<function=([a-zA-Z0-9_\-\.\:\/]+)>\s*(.*?)\s*</function>\s*</tool_call>',
+        clean_text,
+        re.DOTALL,
+    ))
     if xml_matches:
         for idx, m in enumerate(xml_matches):
             fn_name = m.group(1).strip()
@@ -722,8 +729,8 @@ def parse_model_tool_calls(text: str):
             })
             clean_text = clean_text.replace(m.group(0), "")
 
-    # Pattern 2: JSON style  <tool_call> {"name": "...", "arguments": {...}} </tool_call>
-    json_matches = list(re.finditer(r' <tool_call> (\{.*?\})\s*</tool_call>', clean_text, re.DOTALL))
+    # Pattern 2: JSON style <tool_call>{"name": "...", "arguments": {...}}</tool_call>
+    json_matches = list(re.finditer(r'\s*<tool_call>\s*(\{.*?\})\s*</tool_call>', clean_text, re.DOTALL))
     if json_matches and not tool_calls:
         for idx, m in enumerate(json_matches):
             raw_json = m.group(1).strip()
@@ -747,13 +754,13 @@ def parse_model_tool_calls(text: str):
 
     # Extract thinking/reasoning if present
     reasoning_content = None
-    think_m = re.search(r' <think> (.*?) </think>', clean_text, re.DOTALL)
+    think_m = re.search(r'\s*<think>\s*(.*?)\s*</think>', clean_text, re.DOTALL)
     if think_m:
         reasoning_content = think_m.group(1).strip()
         clean_text = clean_text.replace(think_m.group(0), "")
-    elif " </think> " in clean_text:
-        parts = clean_text.split(" </think> ", 1)
-        reasoning_content = parts[0].replace(" <think> ", "").strip()
+    elif "</think>" in clean_text:
+        parts = clean_text.split("</think>", 1)
+        reasoning_content = parts[0].replace("<think>", "").strip()
         clean_text = parts[1]
     elif tool_calls and clean_text.strip():
         # Any text preceding tool calls without  <think> tags is reasoning
@@ -767,6 +774,32 @@ def parse_model_tool_calls(text: str):
     return (tool_calls if tool_calls else None), (reasoning_content if reasoning_content else None), clean_content
 
 
+def normalize_native_tool_calls(tool_calls):
+    """Normalize llama-cpp native calls to the OpenAI response contract.
+
+    Recent llama-cpp versions parse a GGUF chat template themselves and return
+    ``message.tool_calls`` with an empty content field.  Parsing only content
+    silently discarded those valid calls and made the API look non-agentic.
+    """
+    if not tool_calls:
+        return None
+
+    normalized = []
+    for index, call in enumerate(tool_calls):
+        function = call.get("function", {}) if isinstance(call, dict) else {}
+        name = function.get("name") or call.get("name", "")
+        arguments = function.get("arguments", call.get("arguments", {}))
+        if not isinstance(arguments, str):
+            arguments = json.dumps(arguments, ensure_ascii=False)
+        normalized.append({
+            "index": call.get("index", index),
+            "id": call.get("id") or f"call_{uuid.uuid4().hex[:8]}",
+            "type": "function",
+            "function": {"name": name, "arguments": arguments},
+        })
+    return normalized
+
+
 def format_openai_messages_for_model(messages):
     """Normalize multi-turn OpenAI messages including tool results into prompt format."""
     formatted = []
@@ -1551,6 +1584,13 @@ async def openai_chat_completions(request: Request):
     raw_content = raw_message.get("content", "")
     raw_finish = raw_res["choices"][0].get("finish_reason", "stop")
     tool_calls, reasoning, clean_content = parse_model_tool_calls(raw_content)
+    native_tool_calls = normalize_native_tool_calls(raw_message.get("tool_calls"))
+    if native_tool_calls:
+        tool_calls = native_tool_calls
+        # llama-cpp has already removed its native tool block from content.
+        # Preserve any actual assistant text, but do not mislabel it reasoning.
+        if clean_content is None and raw_content:
+            clean_content = raw_content.strip() or None
 
     if stream:
         async def event_generator():

tests/unit/test_zerogpu_tool_calling.py

@@ -0,0 +1,54 @@
+"""Regression coverage for the ZeroGPU OpenAI-compatible tool-call contract."""
+
+from app import normalize_native_tool_calls, parse_model_tool_calls
+
+
+def test_parse_qwen_xml_tool_call_with_newlines():
+    text = """<think>Need project data.</think>
+<tool_call>
+<function=get_project_status>
+<parameter=project>flow</parameter>
+</function>
+</tool_call>"""
+
+    calls, reasoning, content = parse_model_tool_calls(text)
+
+    assert reasoning == "Need project data."
+    assert content is None
+    assert calls == [{
+        "index": 0,
+        "id": calls[0]["id"],
+        "type": "function",
+        "function": {"name": "get_project_status", "arguments": '{"project": "flow"}'},
+    }]
+
+
+def test_parse_qwen_json_tool_call_without_space_padding():
+    calls, reasoning, content = parse_model_tool_calls(
+        '<tool_call>{"name":"get_status","arguments":{"project":"flow"}}</tool_call>'
+    )
+
+    assert reasoning is None
+    assert content is None
+    assert calls[0]["function"] == {
+        "name": "get_status",
+        "arguments": '{"project": "flow"}',
+    }
+
+
+def test_normalize_native_llama_cpp_tool_calls():
+    calls = normalize_native_tool_calls([{
+        "id": "call_native",
+        "type": "function",
+        "function": {"name": "get_project_status", "arguments": {"project": "flow"}},
+    }])
+
+    assert calls == [{
+        "index": 0,
+        "id": "call_native",
+        "type": "function",
+        "function": {
+            "name": "get_project_status",
+            "arguments": '{"project": "flow"}',
+        },
+    }]