Upload app.py

app.py

@@ -85,9 +85,21 @@ def list_models() -> str:
 
 def _parse_tool_calls(text: str):
     """
-    Detect and extract Hermes-style tool calls from model output.
-    Returns (tool_calls, remaining_content) where tool_calls is a list in
-    OpenAI format, or (None, text) if no tool calls are found.
+    Detect and extract tool calls from model output.
+    Handles two formats:
+
+    Format A — Hermes JSON (14b, 30b):
+        <tool_call>{"name": "fn", "arguments": {...}}</tool_call>
+
+    Format B — XML parameters (Qwen3-Coder):
+        <tool_call>
+        <function=fn_name>
+        <parameter=param1>value1</parameter>
+        </function>
+        </tool_call>
+
+    Returns (tool_calls, remaining_content) in OpenAI format,
+    or (None, text) if no tool calls found.
     """
     pattern = r'<tool_call>(.*?)</tool_call>'
     matches = re.findall(pattern, text, re.DOTALL)
@@ -96,8 +108,11 @@ def _parse_tool_calls(text: str):
 
     tool_calls = []
     for match in matches:
+        stripped = match.strip()
+
+        # ── Format A: JSON inside tool_call ──────────────────────────
         try:
-            call = json.loads(match.strip())
+            call = json.loads(stripped)
             tool_calls.append({
                 "id": f"call_{uuid.uuid4().hex[:24]}",
                 "type": "function",
@@ -106,8 +121,32 @@ def _parse_tool_calls(text: str):
                     "arguments": json.dumps(call.get("arguments", call.get("parameters", {}))),
                 },
             })
-        except json.JSONDecodeError:
             continue
+        except json.JSONDecodeError:
+            pass
+
+        # ── Format B: XML <function=name><parameter=k>v</parameter> ──
+        fn_match = re.search(r'<function=([^>]+)>', stripped)
+        if fn_match:
+            fn_name = fn_match.group(1).strip()
+            args = {}
+            for param in re.finditer(r'<parameter=([^>]+)>(.*?)</parameter>', stripped, re.DOTALL):
+                key = param.group(1).strip()
+                val = param.group(2).strip()
+                # Try to coerce to int/float/bool, otherwise keep as string
+                try:
+                    val = json.loads(val)
+                except (json.JSONDecodeError, ValueError):
+                    pass
+                args[key] = val
+            tool_calls.append({
+                "id": f"call_{uuid.uuid4().hex[:24]}",
+                "type": "function",
+                "function": {
+                    "name": fn_name,
+                    "arguments": json.dumps(args),
+                },
+            })
 
     if not tool_calls:
         return None, text
@@ -154,10 +193,31 @@ def chat_completions(
                     "tool_call_id": m.get("tool_call_id", ""),
                 })
             elif role == "assistant" and m.get("tool_calls"):
+                # Normalise tool_calls: apply_chat_template needs arguments as a dict,
+                # but OpenAI format (and our own output) stores them as a JSON string.
+                normalised_tool_calls = []
+                for tc in m["tool_calls"]:
+                    fn = tc.get("function", {})
+                    raw_args = fn.get("arguments", "{}")
+                    if isinstance(raw_args, str):
+                        try:
+                            parsed_args = json.loads(raw_args)
+                        except json.JSONDecodeError:
+                            parsed_args = {}
+                    else:
+                        parsed_args = raw_args  # already a dict
+                    normalised_tool_calls.append({
+                        "id": tc.get("id", ""),
+                        "type": "function",
+                        "function": {
+                            "name": fn.get("name", ""),
+                            "arguments": parsed_args,  # dict, not string
+                        },
+                    })
                 hf_messages.append({
                     "role": "assistant",
                     "content": m.get("content") or "",
-                    "tool_calls": m["tool_calls"],
+                    "tool_calls": normalised_tool_calls,
                 })
             else:
                 hf_messages.append({"role": role, "content": m.get("content", "")})