#!/usr/bin/env python3
"""Normalize Nemotron agentic tool-use JSONL into LFM2.5 template-ready rows.
What it does (CPU only, streaming, no GPU):
1. Canonicalize each record to OpenAI-style `messages` + `tools`:
- `tool_calls[].function.arguments` JSON string -> dict (LFM template raises on strings)
- drop `reasoning_content` / `...` (LFM2.5-VL is non-reasoning)
- drop empty system turns, legacy `function_call`, trailing non-assistant turns
- coerce tool-result content to str
2. Validate: every called tool exists in `tools`, arguments parse, >=1 assistant turn,
source `filter_reason` is null.
3. Render through the real LFM2.5-VL-3B chat template -> `text` with Pythonic
`<|tool_call_start|>[fn(a='v')]<|tool_call_end|>` calls, count tokens, count
assistant (loss) tokens via the template's {% generation %} markers.
4. Round-trip: parse every rendered Pythonic call back and compare name+args to the
canonical call. A row is written only if the round trip is exact.
5. Write parquet shards: messages (json str), tools (json str), text, counts, provenance.
Usage:
python nemotron_to_lfm.py --input data/interactive_agent.jsonl --split interactive_agent \
--source nvidia/Nemotron-SFT-Agentic-v2 --out out/ [--limit N] [--max-tokens 8192]
--input may be a local path or hf:/// (streamed, no download).
"""
import argparse, ast, json, keyword, os, re, sys, time
from collections import Counter
TOOL_CALL_RE = re.compile(r"<\|tool_call_start\|>(.*?)<\|tool_call_end\|>", re.S)
THINK_RE = re.compile(r".*?", re.S)
# ---------------------------------------------------------------- canonicalize
def _as_dict(x):
if isinstance(x, dict):
return x
if isinstance(x, str):
s = x.strip()
if s in ("", "{}", "null", "None"):
return {}
return json.loads(s)
raise ValueError(f"arguments not dict/str: {type(x).__name__}")
def _content_str(c):
if c is None:
return ""
if isinstance(c, str):
return c
if isinstance(c, list): # content parts
return "".join(p.get("text", "") if isinstance(p, dict) else str(p) for p in c)
return json.dumps(c, ensure_ascii=False)
IDENT_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
def sanitize_name(name):
"""MCP/Toucan tools use names like `web-search`; Pythonic calls need identifiers."""
if IDENT_RE.match(name):
return name
n = re.sub(r"\W", "_", name)
if n[:1].isdigit():
n = "_" + n
return n
def canonicalize(rec):
"""Return (messages, tools, reason, renamed). reason is None on success."""
renamed = {}
if rec.get("filter_reason") not in (None, "", "null"):
return None, None, "source_filtered", None
tools = rec.get("tools") or []
if isinstance(tools, str):
try:
tools = json.loads(tools)
except json.JSONDecodeError:
return None, None, "tools_unparseable", None
norm_tools, names = [], set()
for t in tools:
if isinstance(t, str):
try:
t = json.loads(t)
except json.JSONDecodeError:
return None, None, "tool_unparseable", None
fn = t.get("function", t) if isinstance(t, dict) else None
if not isinstance(fn, dict) or not fn.get("name"):
return None, None, "tool_no_name", None
if isinstance(fn.get("parameters"), str):
try:
fn["parameters"] = json.loads(fn["parameters"])
except json.JSONDecodeError:
return None, None, "tool_params_unparseable", None
fn = {k: v for k, v in fn.items() if k in ("name", "description", "parameters")}
new = sanitize_name(fn["name"])
if new != fn["name"]:
renamed[fn["name"]] = new
fn["name"] = new
if new in names:
prev = next(t["function"] for t in norm_tools if t["function"]["name"] == new)
if json.dumps(prev, sort_keys=True) == json.dumps(fn, sort_keys=True):
continue # exact duplicate tool entry (common in LoopTool); keep one
return None, None, "tool_name_collision", None
norm_tools.append({"type": "function", "function": fn})
names.add(new)
out = []
for m in rec.get("messages") or []:
role = m.get("role")
if role == "system":
c = _content_str(m.get("content")).strip()
if c and not out:
out.append({"role": "system", "content": c})
continue
if role == "user":
out.append({"role": "user", "content": _content_str(m.get("content"))})
elif role == "assistant":
c = THINK_RE.sub("", _content_str(m.get("content"))).strip()
calls = []
for tc in m.get("tool_calls") or []:
if isinstance(tc, str):
try:
tc = json.loads(tc)
except json.JSONDecodeError:
return None, None, "tool_call_unparseable", None
fn = tc.get("function", tc)
name = fn.get("name")
if not name:
return None, None, "call_no_name", None
name = renamed.get(name, name)
if name not in names:
return None, None, "call_unknown_tool", None
try:
args = _as_dict(fn.get("arguments"))
except Exception:
return None, None, "args_unparseable", None
args = {k: v for k, v in args.items() if k != ""} # source artefact: {"": {}} == no args
if not all(isinstance(k, str) and IDENT_RE.match(k) for k in args):
return None, None, "bad_arg_name", None
if any(keyword.iskeyword(k) for k in args): # `from=`, `class=` cannot be Pythonic kwargs
return None, None, "keyword_arg_name", None
calls.append({"id": tc.get("id") or f"call_{len(out)}_{len(calls)}", "type": "function",
"function": {"name": name, "arguments": args}})
if not c and not calls:
return None, None, "empty_assistant", None
msg = {"role": "assistant", "content": c}
if calls:
msg["tool_calls"] = calls
out.append(msg)
elif role == "tool":
msg = {"role": "tool", "content": _content_str(m.get("content"))}
if m.get("tool_call_id"):
msg["tool_call_id"] = m["tool_call_id"]
if m.get("name"):
msg["name"] = m["name"]
out.append(msg)
else:
return None, None, f"bad_role_{role}", None
while out and out[-1]["role"] != "assistant":
out.pop()
if not any(m["role"] == "assistant" for m in out):
return None, None, "no_assistant", None
if not any(m["role"] == "user" for m in out):
return None, None, "no_user", None
return out, norm_tools, None, renamed
# ---------------------------------------------------------------- pythonic parse (round trip)
_NAMES = {"true": True, "false": False, "null": None, "True": True, "False": False, "None": None}
def _ev(node):
if isinstance(node, ast.Constant):
return node.value
if isinstance(node, ast.Name) and node.id in _NAMES:
return _NAMES[node.id]
if isinstance(node, (ast.List, ast.Tuple)):
return [_ev(e) for e in node.elts]
if isinstance(node, ast.Dict):
return {_ev(k): _ev(v) for k, v in zip(node.keys, node.values)}
if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
return -_ev(node.operand)
raise ValueError(f"unsupported node {type(node).__name__}")
def parse_pythonic(block):
"""'[f(a=1), g(b='x')]' -> [(name, {args})]. Mirrors what the serving-side parser must do."""
tree = ast.parse(block.strip(), mode="eval").body
if not isinstance(tree, ast.List):
raise ValueError("not a list")
calls = []
for c in tree.elts:
if not isinstance(c, ast.Call) or c.args:
raise ValueError("positional args / non-call")
name = c.func.id if isinstance(c.func, ast.Name) else ast.unparse(c.func)
calls.append((name, {k.arg: _ev(k.value) for k in c.keywords}))
return calls
def roundtrip_ok(messages, text):
expected = [(tc["function"]["name"], tc["function"]["arguments"])
for m in messages if m["role"] == "assistant" for tc in m.get("tool_calls", [])]
got = []
for block in TOOL_CALL_RE.findall(text):
got.extend(parse_pythonic(block))
return got == expected
# ---------------------------------------------------------------- io
def iter_jsonl(path):
if path.startswith("hf://"):
from huggingface_hub import HfFileSystem
f = HfFileSystem().open(path, "r", encoding="utf-8")
else:
f = open(path, "r", encoding="utf-8")
with f:
for line in f:
line = line.strip()
if line:
yield line
# ---------------------------------------------------------------- parallel workers
_TOK = None
def _init_worker(tokenizer_name):
"""Per-process tokenizer; Rust-level parallelism off so N Python workers don't oversubscribe."""
global _TOK
os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
from transformers import AutoTokenizer
_TOK = AutoTokenizer.from_pretrained(tokenizer_name)
def process_line(args):
"""(index, line, split, source, license, max_tokens, no_tokenize) -> (row|None, reason|None, renamed)"""
i, line, split, source, lic, max_tokens, no_tokenize = args
try:
rec = json.loads(line)
except json.JSONDecodeError:
return None, "json", None
messages, tools, why, renamed = canonicalize(rec)
if why:
return None, why, None
tok = _TOK
try:
text = tok.apply_chat_template(messages, tools=tools, tokenize=False)
except Exception as e:
return None, "template:" + type(e).__name__, None
try:
if not roundtrip_ok(messages, text):
return None, "roundtrip_mismatch", None
except Exception:
return None, "roundtrip_parse", None
n_tok = n_ast = -1
if not no_tokenize:
enc = tok.apply_chat_template(messages, tools=tools, tokenize=True, return_dict=True,
return_assistant_tokens_mask=True)
n_tok = len(enc["input_ids"]); n_ast = int(sum(enc["assistant_masks"]))
if n_tok > max_tokens:
return None, "too_long", None
if n_ast == 0:
return None, "no_loss_tokens", None
meta = rec.get("metadata") or {}
rid = rec.get("uuid") or meta.get("uuid") or f"{split}-{i}"
row = {"id": rid, "source": source, "split": split, "license": lic,
"domain": rec.get("domain") or "", "teacher_model": rec.get("model") or "",
"messages": json.dumps(messages, ensure_ascii=False), "tools": json.dumps(tools, ensure_ascii=False),
"text": text, "n_turns": len(messages),
"n_tool_calls": sum(len(m.get("tool_calls", [])) for m in messages if m["role"] == "assistant"),
"n_tools": len(tools), "n_tokens": n_tok, "n_assistant_tokens": n_ast,
"renamed_tools": json.dumps(renamed) if renamed else ""}
return row, None, renamed
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--input", required=True)
ap.add_argument("--split", required=True)
ap.add_argument("--source", default="nvidia/Nemotron-SFT-Agentic-v2")
ap.add_argument("--license", default="cc-by-4.0")
ap.add_argument("--tokenizer", default="LiquidAI/LFM2.5-VL-3B")
ap.add_argument("--out", required=True)
ap.add_argument("--limit", type=int, default=0)
ap.add_argument("--max-tokens", type=int, default=8192)
ap.add_argument("--shard-rows", type=int, default=50000)
ap.add_argument("--no-tokenize", action="store_true", help="skip token counting (faster smoke test)")
ap.add_argument("--workers", type=int, default=0, help="worker processes (default: all CPUs)")
ap.add_argument("--chunk", type=int, default=32, help="lines per task sent to a worker")
a = ap.parse_args()
workers = a.workers or (os.cpu_count() or 1)
import multiprocessing as mp
import pyarrow as pa, pyarrow.parquet as pq
os.makedirs(a.out, exist_ok=True)
stats, rows, shard, t0 = Counter(), [], 0, time.time()
schema = pa.schema([("id", pa.string()), ("source", pa.string()), ("split", pa.string()), ("license", pa.string()),
("domain", pa.string()), ("teacher_model", pa.string()),
("messages", pa.string()), ("tools", pa.string()), ("text", pa.string()),
("n_turns", pa.int32()), ("n_tool_calls", pa.int32()), ("n_tools", pa.int32()),
("n_tokens", pa.int32()), ("n_assistant_tokens", pa.int32()),
("renamed_tools", pa.string())])
def flush():
nonlocal rows, shard
if not rows:
return
path = os.path.join(a.out, f"{a.split}-{shard:05d}.parquet")
pq.write_table(pa.Table.from_pylist(rows, schema=schema), path, compression="zstd")
shard += 1; rows = []
def tasks():
for i, line in enumerate(iter_jsonl(a.input)):
if a.limit and i >= a.limit:
break
yield (i, line, a.split, a.source, a.license, a.max_tokens, a.no_tokenize)
print(f"[workers={workers} chunk={a.chunk}] {a.input}", file=sys.stderr, flush=True)
ctx = mp.get_context("forkserver" if sys.platform != "darwin" else "spawn")
with ctx.Pool(workers, initializer=_init_worker, initargs=(a.tokenizer,)) as pool:
# ordered imap keeps shard contents deterministic; chunksize amortizes IPC
for row, why, renamed in pool.imap(process_line, tasks(), chunksize=a.chunk):
stats["read"] += 1
if why:
stats["drop:" + why] += 1
else:
rows.append(row); stats["kept"] += 1
if renamed:
stats["renamed_rows"] += 1
if len(rows) >= a.shard_rows:
flush()
if stats["read"] % 5000 == 0:
el = time.time() - t0
print(f"[{el:7.0f}s] read={stats['read']} kept={stats['kept']} rate={stats['read']/el:.0f}/s",
file=sys.stderr, flush=True)
flush()
print(json.dumps({"input": a.input, "split": a.split, "elapsed_s": round(time.time()-t0, 1), **stats}, indent=1))
with open(os.path.join(a.out, f"{a.split}-stats.json"), "w") as f:
json.dump(dict(stats), f, indent=1)
if __name__ == "__main__":
main()