xlam_cli.py

"""Lossless positional CLI codec for xLAM's direct parameter mapping.

Run: python xlam_cli.py SOURCE.json --output-dir OUTPUT
This module parses text only; it never invokes a shell or executes a tool.
"""
from __future__ import annotations

import argparse
from collections import Counter
import hashlib
import json
from pathlib import Path

SOURCE = "Salesforce/xlam-function-calling-60k"
FORMAT_VERSION = "xlam-positional-json-values-v3"
MISSING = "__MISSING__"
RULES = (
    "Use the CLI commands below. Arguments are positional in the documented order. "
    "Encode every present value as JSON: quote strings; use numeric, boolean, null, "
    "array and object literals without schema coercion. Use __MISSING__ for an omitted "
    "argument before a later present argument; omit trailing absent arguments. "
    "Emit only calls, one per line, in their intended order. "
    "There are no shell operators or shell expansion."
)


def J(value):
    return json.loads(value) if isinstance(value, str) else value


def compact(value):
    return json.dumps(value, ensure_ascii=False, separators=(",", ":"), allow_nan=False)


def deep_equal(a, b):
    """Compare values AND types; Python's True == 1 and 1 == 1.0 are insufficient."""
    if type(a) is not type(b):
        return False
    if isinstance(a, dict):
        return a.keys() == b.keys() and all(deep_equal(a[k], b[k]) for k in a)
    if isinstance(a, list):
        return len(a) == len(b) and all(deep_equal(x, y) for x, y in zip(a, b))
    return a == b


def params(tool):
    """xLAM parameters are a DIRECT mapping, including any 'properties' argument.

    Do not infer JSON Schema from key names or remove metadata-like names.
    Supporting JSON Schema for another source requires an explicit source adapter.
    """
    raw = tool.get("parameters")
    p = {} if raw is None else J(raw)
    if not isinstance(p, dict):
        raise TypeError(f"{tool.get('name')!r}: parameters must be a direct mapping")
    result = []
    for name, value in p.items():
        if not isinstance(name, str):
            raise TypeError("Argument names must be strings")
        if isinstance(value, dict):
            spec = dict(value)
        elif isinstance(value, str):
            spec = {"type": value}
        elif value is None:
            spec = {}
        else:
            spec = {"raw_schema": value}
        result.append((name, spec))
    return result


def tool_map(tools):
    result = {}
    for tool in tools:
        name = tool["name"]
        if not isinstance(name, str) or not name or any(c.isspace() for c in name):
            raise ValueError(f"Unsupported tool name: {name!r}")
        if name not in result:
            result[name] = {"name": name, "parameters": {}, "_variants": []}
        # A source name can identify several different APIs. The answer does not
        # identify which one. Preserve this ambiguity; never select an API using
        # the answer. The positional order is the union of schema keys, in first
        # appearance order, derived from the tool definitions alone.
        merged = result[name]
        merged["_variants"].append(tool)
        for key, spec in params(tool):
            merged["parameters"].setdefault(key, spec)
    return result


def enc_value(value):
    return compact(value)


def enc_call(answer, tmap):
    if set(answer) != {"name", "arguments"}:
        raise ValueError(f"Unsupported call fields: {list(answer)}")
    name = answer["name"]
    args = J(answer["arguments"])
    if not isinstance(args, dict):
        raise TypeError(f"{name}: arguments must be a mapping")
    order = [k for k, _ in params(tmap[name])]
    unknown = set(args) - set(order)
    if unknown:
        raise ValueError(f"{name}: undeclared arguments {sorted(unknown)!r}")
    last = max((i for i, key in enumerate(order) if key in args), default=-1)
    return " ".join([name] + [enc_value(args[k]) if k in args else MISSING
                              for k in order[:last + 1]])


def dec_call(line, tmap):
    if not isinstance(line, str) or "\n" in line or "\r" in line:
        raise ValueError("A CLI call must be a single physical line")
    name, separator, rest = line.partition(" ")
    if name not in tmap:
        raise ValueError(f"Unknown command {name!r}")
    order = [k for k, _ in params(tmap[name])]
    decoder = json.JSONDecoder()
    pos = 0
    values = []
    while pos < len(rest):
        while pos < len(rest) and rest[pos].isspace():
            pos += 1
        if pos == len(rest):
            break
        if rest.startswith(MISSING, pos):
            end = pos + len(MISSING)
            if end < len(rest) and not rest[end].isspace():
                raise ValueError("Invalid missing-argument marker")
            values.append((False, None))
        else:
            value, end = decoder.raw_decode(rest, pos)
            # Reject non-finite values accepted by Python's permissive JSON decoder.
            compact(value)
            values.append((True, value))
            if end < len(rest) and not rest[end].isspace():
                raise ValueError("CLI values must be separated by whitespace")
        pos = end
    if len(values) > len(order):
        raise ValueError(f"Too many positional arguments for {name}")
    args = {key: value for key, (present, value) in zip(order, values) if present}
    return {"name": name, "arguments": args}


def cli_help(tools):
    blocks = []
    for tool in tool_map(tools).values():
        ps = params(tool)
        usage = " ".join([tool["name"]] + [f"<{k}>" for k, _ in ps])
        lines = [usage]
        variants = tool["_variants"]
        if len(variants) > 1:
            lines.append("  Source repeats this name. All definitions share the positional order above;")
            lines.append("  original answers do not specify a definition ID.")
        for variant_index, variant in enumerate(variants):
            if len(variants) > 1:
                lines.append(f"  Source definition {variant_index + 1}:")
            if variant.get("description"):
                lines.append("  " + str(variant["description"]).replace("\n", "\n  "))
            for key, spec in params(variant):
                details = []
                if "type" in spec:
                    details.append("declared type=" + str(spec["type"]))
                if "required" in spec:
                    details.append("required=" + compact(spec["required"]))
                if "default" in spec:
                    details.append("default=" + compact(spec["default"]))
                text = f"  {key}"
                if details:
                    text += " (" + ", ".join(details) + ")"
                if spec.get("description"):
                    text += ": " + str(spec["description"]).replace("\n", "\n    ")
                lines.append(text)
        blocks.append("\n".join(lines))
    return "\n\n".join(blocks)


def convert(row, row_index=0):
    tools, answers = J(row["tools"]), J(row["answers"])
    tmap = tool_map(tools)
    calls = [enc_call(answer, tmap) for answer in answers]
    decoded = [dec_call(call, tmap) for call in calls]
    if not deep_equal(decoded, answers):
        raise AssertionError(f"Round-trip mismatch in source row {row_index}")
    context = cli_help(tools)
    assistant = "\n".join(calls)
    duplicates = [name for name, tool in tmap.items() if len(tool["_variants"]) > 1]
    ambiguous = [name for name in duplicates if any(
        not deep_equal(tmap[name]["_variants"][0], variant)
        for variant in tmap[name]["_variants"][1:])]
    return {
        "source_id": str(row["id"]),
        "source_row_index": row_index,
        "source_dataset": SOURCE,
        "format_version": FORMAT_VERSION,
        "query": row["query"],
        "tools_json": row["tools"] if isinstance(row["tools"], str) else compact(tools),
        "answers_json": row["answers"] if isinstance(row["answers"], str) else compact(answers),
        "cli_tool_context": context,
        "cli_answers": calls,
        "assistant_cli": assistant,
        "messages": [
            {"role": "system", "content": RULES + "\n\n" + context},
            {"role": "user", "content": row["query"]},
            {"role": "assistant", "content": assistant},
        ],
        "roundtrip_ok": True,
        "call_count": len(calls),
        "duplicate_tool_names": duplicates,
        "ambiguous_tool_names": ambiguous,
        "called_ambiguous_tool_names": [name for name in ambiguous
                                        if any(a["name"] == name for a in answers)],
        "has_ambiguous_tool_names": bool(ambiguous),
    }


def validate_row(row):
    tools, answers = J(row["tools_json"]), J(row["answers_json"])
    tmap = tool_map(tools)
    decoded = [dec_call(call, tmap) for call in row["cli_answers"]]
    if not deep_equal(decoded, answers):
        raise AssertionError(f"Round-trip failure in {row['source_id']}")
    expected = convert({"id": row["source_id"], "query": row["query"],
                        "tools": row["tools_json"], "answers": row["answers_json"]},
                       row["source_row_index"])
    if not deep_equal(expected, row):
        raise AssertionError(f"Derived field mismatch in {row['source_id']}")
    return len(decoded)


def file_sha256(path):
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for block in iter(lambda: f.read(1024 * 1024), b""):
            h.update(block)
    return h.hexdigest()


def regression_tests():
    tool = {"name": "demo", "parameters": {
        "type": {"type": "integer"}, "description": "string", "title": None,
        "properties": {"type": "object", "description": "An actual argument"},
        "optional": {"type": "string"}, "last": {"type": "string"}}}
    tmap = tool_map([tool])
    cases = [
        {"type": 0.3163, "description": "hello world", "title": None,
         "properties": {"nested": [1, "a b", False]}, "last": "__MISSING__"},
        {"last": 'quotes " and \\ and\nnewlines; $(literal)'},
        {"type": "0.3163", "description": True, "title": 1.0},
        {},
    ]
    for args in cases:
        answer = {"name": "demo", "arguments": args}
        assert deep_equal(dec_call(enc_call(answer, tmap), tmap), answer)
    assert not deep_equal(True, 1) and not deep_equal(1, 1.0)
    for line in ['demo 1true', 'demo "unterminated', 'demo [1,2',
                 'demo __MISSING__bad', 'demo NaN', 'unknown 1',
                 'demo 1 2 3 4 5 6 7']:
        try:
            dec_call(line, tmap)
        except (ValueError, KeyError):
            pass
        else:
            raise AssertionError(f"Malformed CLI accepted: {line!r}")
    try:
        enc_call({"name": "demo", "arguments": {"undeclared": 1}}, tmap)
    except ValueError:
        pass
    else:
        raise AssertionError("Unknown argument was silently discarded")
    other = {"name": "demo", "parameters": {"new": "string", "last": "integer"}}
    merged = tool_map([tool, other])
    assert [k for k, _ in params(merged["demo"])] == list(tool["parameters"]) + ["new"]
    answer = {"name": "demo", "arguments": {"new": "from second definition", "type": 0.3163}}
    assert deep_equal(dec_call(enc_call(answer, merged), merged), answer)
    return True


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("source", type=Path)
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--provenance", type=Path)
    ns = parser.parse_args()
    regression_tests()
    rows = json.loads(ns.source.read_text(encoding="utf-8"))
    if not isinstance(rows, list):
        raise TypeError("Source must be a JSON array")
    ns.output_dir.mkdir(parents=True, exist_ok=True)
    import pyarrow as pa
    import pyarrow.parquet as pq
    dataset_path = ns.output_dir / "xlam_cli_train.parquet"
    writer = None
    accepted = 0
    calls = 0
    omitted = 0
    duplicate_rows = ambiguous_rows = called_ambiguous_rows = 0
    schema_names = Counter()
    errors = []
    batch = []
    try:
        for i, row in enumerate(rows):
            try:
                output = convert(row, i)
                calls += output["call_count"]
                tmap = tool_map(J(row["tools"]))
                for answer in J(row["answers"]):
                    order = [k for k, _ in params(tmap[answer["name"]])]
                    args = J(answer["arguments"])
                    last = max((j for j, key in enumerate(order) if key in args), default=-1)
                    omitted += sum(key not in args for key in order[:last + 1])
                duplicate_rows += bool(output["duplicate_tool_names"])
                ambiguous_rows += output["has_ambiguous_tool_names"]
                called_ambiguous_rows += bool(output["called_ambiguous_tool_names"])
                for tool in J(row["tools"]):
                    schema_names.update(k for k, _ in params(tool))
                batch.append(output)
                accepted += 1
            except Exception as exc:
                errors.append({"index": i, "source_id": str(row.get("id")),
                               "error": type(exc).__name__, "message": str(exc)})
            if len(batch) >= 1000 or (i == len(rows) - 1 and batch):
                schema = writer.schema if writer else pa.schema([
                    ("source_id", pa.string()), ("source_row_index", pa.int64()),
                    ("source_dataset", pa.string()), ("format_version", pa.string()),
                    ("query", pa.string()), ("tools_json", pa.string()),
                    ("answers_json", pa.string()), ("cli_tool_context", pa.string()),
                    ("cli_answers", pa.list_(pa.string())), ("assistant_cli", pa.string()),
                    ("messages", pa.list_(pa.struct([("role", pa.string()), ("content", pa.string())]))),
                    ("roundtrip_ok", pa.bool_()), ("call_count", pa.int64()),
                    ("duplicate_tool_names", pa.list_(pa.string())),
                    ("ambiguous_tool_names", pa.list_(pa.string())),
                    ("called_ambiguous_tool_names", pa.list_(pa.string())),
                    ("has_ambiguous_tool_names", pa.bool_()),
                ])
                table = pa.Table.from_pylist(batch, schema=schema)
                if writer is None:
                    writer = pq.ParquetWriter(dataset_path, table.schema, compression="zstd")
                writer.write_table(table)
                batch.clear()
            if (i + 1) % 10000 == 0:
                print(f"Converted {i + 1:,}/{len(rows):,} rows", flush=True)
    finally:
        if writer:
            writer.close()
    report = {"format_version": FORMAT_VERSION, "source_rows": len(rows),
              "accepted_rows": accepted, "failed_rows": len(errors),
              "validated_calls": calls, "missing_argument_markers": omitted,
              "rows_with_duplicate_tool_names": duplicate_rows,
              "rows_with_ambiguous_tool_names": ambiguous_rows,
              "rows_calling_ambiguous_tool_names": called_ambiguous_rows,
              "duplicate_name_policy": "union of parameters in first-appearance order; preserve all definitions and flag ambiguity",
              "source_sha256": file_sha256(ns.source),
              "dataset_sha256": file_sha256(dataset_path) if dataset_path.exists() else None,
              "source_provenance": json.loads(ns.provenance.read_text()) if ns.provenance else {},
              "schema_argument_name_counts": dict(schema_names.most_common()),
              "errors": errors}
    (ns.output_dir / "validation_report.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
    if errors:
        raise RuntimeError(f"{len(errors)} rows failed; see validation_report.json. Do not publish.")
    # Read back the exported file, independently validating every serialized row.
    read_rows = read_calls = 0
    for record_batch in pq.ParquetFile(dataset_path).iter_batches(batch_size=1000):
        for row in record_batch.to_pylist():
            read_calls += validate_row(row)
            read_rows += 1
    assert read_rows == accepted and read_calls == calls
    report["parquet_readback_rows"] = read_rows
    report["parquet_readback_calls"] = read_calls
    report["all_checks_passed"] = True
    (ns.output_dir / "validation_report.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
    print(f"Validated {accepted:,} rows and {calls:,} calls; exported {dataset_path}", flush=True)


if __name__ == "__main__":
    main()