Fix xLAM tool schemas + dpevzner config

train_securecoder.py

@@ -83,7 +83,7 @@ MIX: list[Source] = [
            note="broad security Q&A"),
     Source("Humanlearning/CyberSecurity_OWASP-sft-dataset", 3000, "messages",
            note="OWASP / secure-coding SFT"),
-    Source("dpevzner/Cybersecurity_Reasoning_Dataset", 3000, "secops", "default", "test",
+    Source("dpevzner/Cybersecurity_Reasoning_Dataset", 3000, "secops", "chatml", "train",
            note="command interpretation reasoning (goal -> unified_interpretation)"),
     Source("MrClipperz134/CTF-Instruct", 3000, "io",
            note="CTF instruction/output"),
@@ -123,6 +123,52 @@ def _as_list(value: Any) -> list:
     return []
 
 
+TYPE_ALIASES = {
+    "str": "string", "string": "string", "text": "string",
+    "int": "integer", "integer": "integer", "long": "integer",
+    "float": "number", "double": "number", "number": "number",
+    "bool": "boolean", "boolean": "boolean",
+    "list": "array", "array": "array", "dict": "object", "object": "object",
+}
+
+
+def _normalise_parameters(params: Any) -> dict:
+    """Coerce a tool's parameter spec into valid JSON Schema.
+
+    Two shapes appear in the wild: proper ``{"type": "object", "properties": {}}``
+    and the flat ``{"arg": {"description": ..., "type": "str"}}`` form used by
+    xLAM. Qwen's chat template reads ``parameters.properties``, so the flat form
+    has to be wrapped or rendering raises.
+    """
+    if not isinstance(params, dict) or not params:
+        return {"type": "object", "properties": {}}
+
+    if "properties" in params:
+        params.setdefault("type", "object")
+        return params
+
+    properties: dict[str, Any] = {}
+    required: list[str] = []
+    for name, spec in params.items():
+        if isinstance(spec, dict):
+            cleaned = {
+                k: v for k, v in spec.items()
+                if k in ("type", "description", "enum", "default", "title", "items")
+            }
+            cleaned["type"] = TYPE_ALIASES.get(str(cleaned.get("type", "")).lower(), "string")
+            properties[name] = cleaned
+            if "default" not in spec:
+                required.append(name)
+        else:
+            properties[name] = {"type": "string"}
+            required.append(name)
+
+    schema: dict[str, Any] = {"type": "object", "properties": properties}
+    if required:
+        schema["required"] = required
+    return schema
+
+
 def _normalise_tool_schema(tool: Any) -> dict | None:
     """Force a tool schema into the shape Qwen's chat template expects:
     {"type": "function", "function": {"name", "description", "parameters"}}."""
@@ -136,11 +182,12 @@ def _normalise_tool_schema(tool: Any) -> dict | None:
         "function": {
             "name": fn["name"],
             "description": fn.get("description", ""),
-            "parameters": fn.get("parameters") or {"type": "object", "properties": {}},
+            "parameters": _normalise_parameters(fn.get("parameters")),
         },
     }
 
 
+
 def _parse_calls(value: Any) -> list[dict] | None:
     """Return OpenAI tool_calls if ``value`` is one or more JSON function calls."""
     if isinstance(value, str):
@@ -215,7 +262,14 @@ def _messages_from_any(row: dict, kind: str) -> tuple[list[dict], list[dict]]:
 
     # --- xLAM: query + answers + tools ------------------------------------
     if kind == "xlam" or (row.get("query") and row.get("answers")):
-        calls = _parse_calls(_as_list(row.get("answers")))
+        answers = _as_list(row.get("answers"))
+        calls = _parse_calls(answers)
+        if calls is None and answers:
+            # answers can be a list of JSON strings instead of one JSON array
+            flat: list = []
+            for item in answers:
+                flat.extend(_as_list(item))
+            calls = _parse_calls(flat)
         if calls and row.get("query"):
             messages.append({"role": "user", "content": str(row["query"])})
             messages.append({"role": "assistant", "content": None, "tool_calls": calls})
@@ -252,7 +306,7 @@ def _messages_from_any(row: dict, kind: str) -> tuple[list[dict], list[dict]]:
         return messages, tools
 
     # --- SecOps reasoning: goal/command -> unified_interpretation ---------
-    if kind == "secops" and row.get("unified_interpretation"):
+    if row.get("unified_interpretation"):
         ask = [f"Tool: {row.get('tool', 'shell')}", f"Goal: {row.get('goal', '')}"]
         for key in ("command", "command_sequence", "nmap_context"):
             if row.get(key):