code/vc_sft.py

#!/usr/bin/env python3
"""Turns saved tau2 conversations into fine-tuning examples for Qwen 3.5 (thinking kept).

One example = the conversation up to one customer message, plus the agent's whole answer to it (its reasoning, tool
calls, tool results and final reply). Only the agent's own turns in that answer are trained on. Reasoning is kept for
those turns and left out of earlier ones, which is exactly how the model's chat template lays a conversation out.

build:  vc_sft.py build <out.jsonl> <results.json> [<results.json> ...]      (run with the tau2 environment's python)
check:  vc_sft.py check <examples.jsonl> <tokenizer dir or model name>         (needs transformers)
"""
import collections
import json
import random
import sys

WRITES = {"book_reservation", "cancel_reservation", "update_reservation_flights", "update_reservation_passengers",
          "update_reservation_baggages", "send_certificate"}
FALLBACK = "One moment please while I look into this for you."
HINT_WORDS = ("resolution step", "resolution_step", "<resolution", "steps provided", "provided steps")
ASSISTANT, END = "<|im_start|>assistant\n", "<|im_end|>\n"


def family_of(task):
    try:
        return json.loads(task["description"]["notes"])["family"]
    except Exception:
        return "official"


def to_chat(m):
    """One saved tau2 message as a chat-template message, with the model's own reasoning when it was recorded."""
    if m["role"] == "user":
        return {"role": "user", "content": m.get("content") or ""}
    if m["role"] == "tool":
        return {"role": "tool", "content": m.get("content") or ""}
    out = {"role": "assistant", "content": m.get("content") or ""}
    if m.get("tool_calls"):
        out["tool_calls"] = [{"type": "function", "function": {"name": c["name"], "arguments": c["arguments"]}} for c in m["tool_calls"]]
    choice = (((m.get("raw_data") or {}).get("choices") or [{}])[0].get("message") or {})
    thinking = choice.get("reasoning_content") or choice.get("reasoning")
    if thinking:
        out["reasoning_content"] = thinking.strip()
    return out


def build(paths, max_chains=3, family_cap=70, seed=5):
    from tau2.agent.llm_agent import AGENT_INSTRUCTION, SYSTEM_PROMPT
    from tau2.registry import registry

    env = registry.get_env_constructor("airline")()
    system = {"role": "system", "content": SYSTEM_PROMPT.format(domain_policy=env.get_policy(), agent_instruction=AGENT_INSTRUCTION)}
    tools = [t.openai_schema for t in env.get_tools()]
    rng = random.Random(seed)
    convs, skipped = [], collections.Counter()
    for path in paths:
        d = json.load(open(path))
        fam = {t["id"]: family_of(t) for t in d["tasks"]}
        for s in d["simulations"]:
            if abs(((s.get("reward_info") or {}).get("reward") or 0.0) - 1.0) > 1e-6:
                skipped["did not pass"] += 1
                continue
            msgs = [to_chat(m) for m in s.get("messages") or []]
            text = " ".join((m.get("content") or "") + " " + (m.get("reasoning_content") or "") for m in msgs if m["role"] == "assistant")
            if FALLBACK in text:
                skipped["used the holding sentence"] += 1
                continue
            if any(w in text.lower() for w in HINT_WORDS):
                skipped["mentions hints"] += 1
                continue
            convs.append((fam.get(s["task_id"], "official"), s["task_id"], s.get("trial"), msgs))
    rng.shuffle(convs)
    kept, per_family = [], collections.Counter()
    for fam, tid, trial, msgs in convs:
        key, cap = (fam, family_cap) if fam != "official" else ("official task %s" % tid, 6)   # benchmark tasks: six runs each at most
        if per_family[key] >= cap:
            skipped["over the family cap"] += 1
            continue
        per_family[key] += 1
        kept.append((fam, tid, trial, msgs))
    examples = []
    for fam, tid, trial, msgs in kept:
        users = [i for i, m in enumerate(msgs) if m["role"] == "user"]
        chains = []
        for n, i in enumerate(users):
            end = users[n + 1] if n + 1 < len(users) else len(msgs)
            if end - i > 1:                                   # the agent said or did something after this customer message
                acts = [c["function"]["name"] for m in msgs[i + 1:end] for c in m.get("tool_calls", [])]
                score = 2 * any(a in WRITES for a in acts) + rng.random()      # answers that change the database first
                chains.append((score, i, end))
        if not chains:
            continue
        last = max(chains, key=lambda c: c[1])
        picked = {last[1:]} | {c[1:] for c in sorted(chains, reverse=True)[:max_chains]}
        for i, end in sorted(picked)[-max_chains:] if len(picked) > max_chains else sorted(picked):
            history = [{k: v for k, v in m.items() if k != "reasoning_content"} for m in msgs[:i + 1]]
            examples.append({"id": "%s/%s/%d" % (tid, trial, i), "family": fam, "chain_start": i + 2,   # +1 for the system message
                             "messages": [system] + history + msgs[i + 1:end], "tools": tools})
    return examples, per_family, skipped


def render(example, tokenizer, max_tokens=16384):
    """Token ids and labels for one example: labels are -100 everywhere except the agent's turns in the answer."""
    msgs, start = example["messages"], example["chain_start"]
    full = tokenizer.apply_chat_template(msgs, tools=example["tools"], tokenize=False, add_generation_prompt=False)
    prefix = tokenizer.apply_chat_template(msgs[:start], tools=example["tools"], tokenize=False, add_generation_prompt=False)
    assert full.startswith(prefix), "the template laid the history out differently once the answer was added"
    spans, pos = [], len(prefix)
    while True:
        a = full.find(ASSISTANT, pos)
        if a < 0:
            break
        b = full.index(END, a) + len(END)
        spans.append((a + len(ASSISTANT), b))
        pos = b
    assert spans and len(spans) == sum(m["role"] == "assistant" for m in msgs[start:]), "agent turns not found in the rendered text"
    enc = tokenizer(full, add_special_tokens=False, return_offsets_mapping=True)
    ids, labels = enc["input_ids"], []
    for tok, (s, e) in zip(ids, enc["offset_mapping"]):
        labels.append(tok if any(s >= a and e <= b for a, b in spans) and e > s else -100)
    if len(ids) > max_tokens:
        return None
    return {"input_ids": ids, "labels": labels, "text": full, "spans": spans}


if __name__ == "__main__":
    mode = sys.argv[1]
    if mode == "build":
        out, paths = sys.argv[2], sys.argv[3:]
        examples, per_family, skipped = build(paths)
        with open(out, "w") as f:
            for e in examples:
                f.write(json.dumps(e) + "\n")
        print("conversations kept by family:", dict(sorted(per_family.items())))
        print("skipped:", dict(skipped))
        print("EXAMPLES:", len(examples), "from", sum(per_family.values()), "conversations ->", out)
    else:
        from transformers import AutoTokenizer
        tok = AutoTokenizer.from_pretrained(sys.argv[3])
        rows = [json.loads(l) for l in open(sys.argv[2])]
        lens, trained, dropped = [], [], 0
        for e in rows:
            r = render(e, tok)
            if r is None:
                dropped += 1
                continue
            lens.append(len(r["input_ids"]))
            trained.append(sum(x != -100 for x in r["labels"]))
        lens.sort()
        print("examples %d | too long %d | tokens median %d, p90 %d, max %d | trained-on tokens per example median %d | total tokens %.1fM" % (
            len(lens), dropped, lens[len(lens) // 2], lens[int(len(lens) * 0.9)], lens[-1], sorted(trained)[len(trained) // 2], sum(lens) / 1e6))
        r = render(rows[0], tok)
        shown = "".join(r["text"][a:b] for a, b in r["spans"])
        print("--- what the model is trained to write in the first example ---\n" + shown[:900])