init save

.gitignore

@@ -0,0 +1,138 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.idea
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+applications/DeepSpeed-Chat/data
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Others
+/.vscode/
+/wandb/
+/.data/
+/.models*/
+/logs/

src/cua_data/preprocessing/opencua/README.md

@@ -0,0 +1,27 @@
+
+```shell
+huggingface-cli download xlangai/AgentNet --repo-type dataset --local-dir .data/huggingface/xlangai/AgentNet
+```
+
+```shell
+# 1. Navigate to the directory
+cd .data/huggingface/xlangai/AgentNet/{ubuntu_images,win_mac_images}
+
+# 2. Merge split volumes into a single archive (images-full.zip)
+zip -s 0 images.zip --out images-full.zip
+
+# 3. Extract the merged archive
+unzip images-full.zip -d ../{extracted_ubuntu_images,win_mac_images}
+
+# 4. (Optional) Return to the parent directory
+cd ..
+```
+
+```shell
+# process 1/256 of the dataset
+python src/cua_data/preprocessing/opencua/opencua.py \
+    --jsonl_path ".data/huggingface/xlangai/AgentNet/agentnet_ubuntu_5k.jsonl" \
+    --extracted_images_dir ".data/huggingface/xlangai/AgentNet/extracted_ubuntu_images" \
+    --output_path ".data/scalecua/ubuntu" \
+    --rank 0 --world_size 256 --overwrite
+```

src/cua_data/preprocessing/opencua/opencua.py

@@ -0,0 +1,987 @@
+#!/usr/bin/env python3
+"""Convert AgentNet JSONL trajectories into a HuggingFace dataset.
+
+Each JSONL line is expected to be a single task record with at least:
+  - instruction: str
+  - traj: list[step]
+    - step.image: str (image filename)
+    - step.value.thought: str
+    - step.value.action: str
+    - step.value.code: str (pyautogui/computer action code)
+
+Output dataset:
+  - images: list[PIL.Image.Image]
+  - messages: list[dict] in a multi-turn user/assistant format.
+
+Error handling (strict):
+  1) Raises if final action is not terminate.
+  2) Raises if any referenced image file is missing/unreadable.
+  3) Raises on any JSON/parsing/unexpected code formats.
+
+Requires:
+  pip install datasets pillow tyro
+
+Sharding (contiguous):
+  - If rank and world_size are specified (both not None), rank=0 processes the
+    first 1/world_size chunk of the dataset (by JSONL order), rank=1 the next
+    chunk, etc.
+  - Shards are saved to:
+      {output_path}/shard_{rank}of{world_size}
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from PIL import Image as PILImage
+import tqdm
+import tyro
+
+
+# -----------------------------
+# Args
+# -----------------------------
+
+@dataclass
+class ScriptArguments:
+    jsonl_path: str = ".data/huggingface/xlangai/AgentNet/agentnet_ubuntu_5k.jsonl"
+    extracted_images_dir: str = ".data/huggingface/xlangai/AgentNet/extracted_ubuntu_images"
+    output_path: str = ".data/scalecua/ubuntu"
+    rank: Optional[int] = None
+    world_size: Optional[int] = None
+    overwrite: bool = False
+
+
+# -----------------------------
+# Qwen3-VL tool call formatting
+# -----------------------------
+
+def _make_computer_use_tool_call(arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """Wrap a computer_use tool call in Qwen3-VL tool_call structure."""
+    if "action" not in arguments:
+        raise ValueError(f"computer_use arguments must include 'action'. Got: {arguments}")
+    return {
+        "type": "function",
+        "function": {
+            "name": "computer_use",
+            "arguments": arguments,
+        },
+    }
+
+
+# -----------------------------
+# AgentNet code parsing
+# -----------------------------
+
+class AgentNetCodeParseError(RuntimeError):
+    pass
+
+
+def _dotted_name(expr: ast.AST) -> str:
+    """Return dotted name for ast.Name / ast.Attribute chains, else empty string."""
+    if isinstance(expr, ast.Name):
+        return expr.id
+    if isinstance(expr, ast.Attribute):
+        base = _dotted_name(expr.value)
+        return f"{base}.{expr.attr}" if base else expr.attr
+    return ""
+
+
+def _literal_eval(node: ast.AST) -> Any:
+    try:
+        return ast.literal_eval(node)
+    except Exception as e:
+        raise AgentNetCodeParseError(f"Failed literal_eval on node={ast.dump(node)}") from e
+
+
+def _get_kw(call: ast.Call, name: str) -> Optional[ast.AST]:
+    for kw in call.keywords:
+        if kw.arg == name:
+            return kw.value
+    return None
+
+
+def _extract_xy(call: ast.Call) -> Tuple[float, float]:
+    """Extract x,y from a pyautogui-like call.
+
+    Supports keyword x=, y= (preferred), or positional (x, y).
+    """
+    x_node = _get_kw(call, "x")
+    y_node = _get_kw(call, "y")
+
+    if x_node is None and len(call.args) >= 1:
+        x_node = call.args[0]
+    if y_node is None and len(call.args) >= 2:
+        y_node = call.args[1]
+
+    if x_node is None or y_node is None:
+        raise AgentNetCodeParseError(
+            f"Expected x and y arguments, got args={len(call.args)} keywords={[kw.arg for kw in call.keywords]}"
+        )
+
+    x = float(_literal_eval(x_node))
+    y = float(_literal_eval(y_node))
+    return x, y
+
+
+def _norm01_to_0_1000(x: float, y: float) -> List[int]:
+    """Convert normalized [0,1] floats -> int [0,1000] with rounding."""
+    eps = 1e-6
+    if x < -eps or x > 1 + eps or y < -eps or y > 1 + eps:
+        raise AgentNetCodeParseError(f"Coordinates out of normalized range [0,1]: x={x}, y={y}")
+    xi = int(round(x * 1000))
+    yi = int(round(y * 1000))
+    xi = max(0, min(1000, xi))
+    yi = max(0, min(1000, yi))
+    return [xi, yi]
+
+
+def agentnet_code_to_qwen_tool_calls(code: str) -> List[Dict[str, Any]]:
+    """Convert AgentNet pyautogui/computer code string into Qwen3-VL computer_use tool calls."""
+    if not isinstance(code, str) or not code.strip():
+        raise AgentNetCodeParseError(f"Expected non-empty code string. Got: {code!r}")
+
+    try:
+        module = ast.parse(code)
+    except Exception as e:
+        raise AgentNetCodeParseError(f"ast.parse failed for code:\n{code}") from e
+
+    tool_calls: List[Dict[str, Any]] = []
+
+    for stmt in module.body:
+        if not isinstance(stmt, ast.Expr) or not isinstance(stmt.value, ast.Call):
+            raise AgentNetCodeParseError(
+                f"Unsupported statement type: {type(stmt).__name__}. Only expression calls are supported.\ncode=\n{code}"
+            )
+
+        call: ast.Call = stmt.value
+        fname = _dotted_name(call.func)
+
+        # ---- Mouse clicks ----
+        if fname == "pyautogui.click":
+            x, y = _extract_xy(call)
+            tool_calls.append(
+                _make_computer_use_tool_call({"action": "left_click", "coordinate": _norm01_to_0_1000(x, y)})
+            )
+            continue
+
+        if fname == "pyautogui.rightClick":
+            x, y = _extract_xy(call)
+            tool_calls.append(
+                _make_computer_use_tool_call({"action": "right_click", "coordinate": _norm01_to_0_1000(x, y)})
+            )
+            continue
+
+        if fname == "pyautogui.middleClick":
+            x, y = _extract_xy(call)
+            tool_calls.append(
+                _make_computer_use_tool_call({"action": "middle_click", "coordinate": _norm01_to_0_1000(x, y)})
+            )
+            continue
+
+        if fname == "pyautogui.doubleClick":
+            x, y = _extract_xy(call)
+            tool_calls.append(
+                _make_computer_use_tool_call({"action": "double_click", "coordinate": _norm01_to_0_1000(x, y)})
+            )
+            continue
+
+        if fname in {"pyautogui.tripleClick", "computer.tripleClick"}:
+            x, y = _extract_xy(call)
+            tool_calls.append(
+                _make_computer_use_tool_call({"action": "double_click", "coordinate": _norm01_to_0_1000(x, y)})
+            )
+            continue
+
+        # ---- Mouse movement / drag ----
+        if fname == "pyautogui.moveTo":
+            x, y = _extract_xy(call)
+            tool_calls.append(
+                _make_computer_use_tool_call({"action": "mouse_move", "coordinate": _norm01_to_0_1000(x, y)})
+            )
+            continue
+
+        if fname == "pyautogui.dragTo":
+            btn_node = _get_kw(call, "button")
+            btn = "left" if btn_node is None else str(_literal_eval(btn_node))
+            if btn != "left":
+                raise AgentNetCodeParseError(
+                    f"Only button='left' dragTo is supported. Got button={btn!r}.\ncode=\n{code}"
+                )
+            x, y = _extract_xy(call)
+            tool_calls.append(
+                _make_computer_use_tool_call({"action": "left_click_drag", "coordinate": _norm01_to_0_1000(x, y)})
+            )
+            continue
+
+        # ---- Scroll ----
+        if fname in {"pyautogui.scroll", "pyautogui.hscroll"}:
+            if len(call.args) < 1:
+                raise AgentNetCodeParseError(f"scroll/hscroll requires a pixels argument.\ncode=\n{code}")
+            pixels = int(_literal_eval(call.args[0]))
+            tool_calls.append(_make_computer_use_tool_call({"action": "scroll", "pixels": pixels}))
+            continue
+
+        # ---- Keyboard ----
+        if fname == "pyautogui.hotkey":
+            if len(call.args) != 1:
+                raise AgentNetCodeParseError(f"hotkey expected a single list argument.\ncode=\n{code}")
+            keys_val = _literal_eval(call.args[0])
+            if not isinstance(keys_val, (list, tuple)) or not keys_val:
+                raise AgentNetCodeParseError(f"hotkey arg must be a non-empty list/tuple. Got: {keys_val!r}")
+            keys = [str(k).lower() for k in keys_val]
+            tool_calls.append(_make_computer_use_tool_call({"action": "key", "keys": keys}))
+            continue
+
+        if fname == "pyautogui.press":
+            if len(call.args) != 1:
+                raise AgentNetCodeParseError(f"press expected a single key argument.\ncode=\n{code}")
+            key_val = _literal_eval(call.args[0])
+            if isinstance(key_val, (list, tuple)):
+                for k in key_val:
+                    tool_calls.append(_make_computer_use_tool_call({"action": "key", "keys": [str(k).lower()]}))
+            else:
+                tool_calls.append(_make_computer_use_tool_call({"action": "key", "keys": [str(key_val).lower()]}))
+            continue
+
+        if fname in {"pyautogui.write", "pyautogui.typewrite"}:
+            msg_node = _get_kw(call, "message")
+            if msg_node is None and len(call.args) == 1:
+                msg_node = call.args[0]
+            if msg_node is None:
+                raise AgentNetCodeParseError(f"write/typewrite requires message argument.\ncode=\n{code}")
+            text = str(_literal_eval(msg_node))
+            tool_calls.append(_make_computer_use_tool_call({"action": "type", "text": text}))
+            continue
+
+        # ---- Wait / Terminate ----
+        if fname == "computer.wait":
+            if len(call.args) == 0 and len(call.keywords) == 0:
+                t = 1.0
+            elif len(call.args) == 1 and len(call.keywords) == 0:
+                t = float(_literal_eval(call.args[0]))
+            else:
+                raise AgentNetCodeParseError(f"Unsupported wait signature.\ncode=\n{code}")
+            tool_calls.append(_make_computer_use_tool_call({"action": "wait", "time": t}))
+            continue
+
+        if fname == "computer.terminate":
+            status_node = _get_kw(call, "status")
+            if status_node is None:
+                raise AgentNetCodeParseError(f"terminate requires status='success'|'failure'.\ncode=\n{code}")
+            status = str(_literal_eval(status_node))
+            if status not in {"success", "failure"}:
+                raise AgentNetCodeParseError(f"Unsupported terminate status={status!r}.\ncode=\n{code}")
+            tool_calls.append(_make_computer_use_tool_call({"action": "terminate", "status": status}))
+            continue
+
+        raise AgentNetCodeParseError(f"Unsupported function call: {fname!r}.\ncode=\n{code}")
+
+    return tool_calls
+
+
+# -----------------------------
+# Trajectory -> dataset example
+# -----------------------------
+
+def _load_image_or_raise(path: Path) -> PILImage.Image:
+    if not path.exists():
+        raise FileNotFoundError(f"Missing image file: {path}")
+    try:
+        with PILImage.open(path) as im:
+            return im.convert("RGB").copy()
+    except Exception as e:
+        raise RuntimeError(f"Failed to open image: {path}") from e
+
+
+def record_to_example(record: Dict[str, Any], extracted_images_dir: Path) -> Dict[str, Any]:
+    """Convert one JSONL record into one dataset row with keys: images, messages."""
+    instruction = record.get("instruction")
+    if not isinstance(instruction, str) or not instruction.strip():
+        raise ValueError(f"Missing/invalid 'instruction' in record. Keys={list(record.keys())}")
+
+    traj = record.get("traj")
+    if not isinstance(traj, list) or len(traj) == 0:
+        raise ValueError(f"Missing/invalid 'traj' in record. task_id={record.get('task_id')}")
+
+    images: List[PILImage.Image] = []
+    for i, step in enumerate(traj):
+        img_name = step.get("image")
+        if not isinstance(img_name, str) or not img_name:
+            raise ValueError(
+                f"Missing/invalid step.image at traj[{i}]. task_id={record.get('task_id')} step={step}"
+            )
+        img_path = extracted_images_dir / img_name
+        images.append(_load_image_or_raise(img_path))
+
+    messages: List[Dict[str, Any]] = []
+
+    messages.append(
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "index": 0},
+                {"type": "text", "text": instruction},
+            ],
+        }
+    )
+
+    for i, step in enumerate(traj):
+        value = step.get("value")
+        if not isinstance(value, dict):
+            raise ValueError(f"Missing/invalid step.value at traj[{i}] task_id={record.get('task_id')}")
+
+        thought = value.get("thought")
+        action_text = value.get("action")
+        code = value.get("code")
+
+        if not isinstance(thought, str):
+            raise ValueError(f"Missing/invalid value.thought at traj[{i}] task_id={record.get('task_id')}")
+        if not isinstance(action_text, str):
+            raise ValueError(f"Missing/invalid value.action at traj[{i}] task_id={record.get('task_id')}")
+        if not isinstance(code, str):
+            raise ValueError(f"Missing/invalid value.code at traj[{i}] task_id={record.get('task_id')}")
+
+        tool_calls = agentnet_code_to_qwen_tool_calls(code)
+
+        messages.append(
+            {
+                "role": "assistant",
+                "reasoning_content": thought,
+                "content": [{"type": "text", "text": action_text}],
+                "tool_calls": tool_calls,
+            }
+        )
+
+        if i != len(traj) - 1:
+            messages.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "image", "index": i + 1},
+                    ],
+                }
+            )
+
+    last_step_tool_calls = messages[-1].get("tool_calls")
+    if not isinstance(last_step_tool_calls, list) or len(last_step_tool_calls) == 0:
+        raise ValueError(f"Last assistant message has no tool_calls. task_id={record.get('task_id')}")
+
+    last_call = last_step_tool_calls[-1]
+    try:
+        last_action = last_call["function"]["arguments"]["action"]
+    except Exception:
+        raise ValueError(
+            f"Malformed tool_call structure in last step. task_id={record.get('task_id')} tool_call={last_call}"
+        )
+
+    if last_action != "terminate":
+        raise ValueError(
+            f"Final action is not terminate. task_id={record.get('task_id')} final_action={last_action!r}"
+        )
+
+    return {"images": images, "messages": messages}
+
+
+def compute_shard_range(num_records: int, rank: int, world_size: int) -> Tuple[int, int]:
+    """Contiguous shard ranges.
+
+    Ensures:
+      - rank=0 gets the first chunk
+      - total coverage is exact (some ranks may get +1 if num_records % world_size != 0)
+    """
+    if world_size <= 0:
+        raise ValueError(f"Invalid world_size={world_size}")
+    if rank < 0 or rank >= world_size:
+        raise ValueError(f"Invalid rank={rank} for world_size={world_size}")
+
+    shard_size = num_records // world_size
+    remainder = num_records % world_size
+
+    start = rank * shard_size + min(rank, remainder)
+    end = start + shard_size + (1 if rank < remainder else 0)
+    return start, end
+
+
+def _count_nonempty_lines(jsonl_path: Path) -> int:
+    n = 0
+    with jsonl_path.open("r", encoding="utf-8") as f:
+        for line in f:
+            if line.strip():
+                n += 1
+    return n
+
+
+def iter_examples(
+    jsonl_path: Path,
+    extracted_images_dir: Path,
+    rank: Optional[int] = None,
+    world_size: Optional[int] = None,
+) -> Iterable[Dict[str, Any]]:
+    """Yield dataset rows from a JSONL file, optionally sharded contiguously by (rank, world_size)."""
+    if (rank is None) ^ (world_size is None):
+        raise ValueError("rank and world_size must be both specified or both None.")
+    if rank is not None:
+        if world_size is None:
+            raise ValueError("world_size must be provided if rank is provided.")
+        if world_size <= 0:
+            raise ValueError(f"Invalid world_size={world_size}")
+        if rank < 0 or rank >= world_size:
+            raise ValueError(f"Invalid rank={rank} for world_size={world_size}")
+
+    num_records = _count_nonempty_lines(jsonl_path)
+    if rank is not None:
+        start, end = compute_shard_range(num_records, rank, world_size)  # [start, end)
+    else:
+        start, end = 0, num_records
+
+    record_idx = 0  # counts non-empty JSONL lines
+    with jsonl_path.open("r", encoding="utf-8") as f:
+        for line_no, line in tqdm.tqdm(enumerate(f, start=1)):
+            line = line.strip()
+            if not line:
+                continue
+
+            if record_idx < start:
+                record_idx += 1
+                continue
+            if record_idx >= end:
+                break
+
+            try:
+                record = json.loads(line)
+            except Exception as e:
+                raise ValueError(f"JSON parse error at line {line_no} (record_idx={record_idx}) in {jsonl_path}") from e
+
+            if not isinstance(record, dict):
+                raise ValueError(f"Expected JSON object at line {line_no} (record_idx={record_idx})")
+
+            yield record_to_example(record, extracted_images_dir=extracted_images_dir)
+            record_idx += 1
+
+
+def build_features() -> Any:
+    """Define HuggingFace datasets Features for stable serialization."""
+    from datasets import Features, Image, Sequence, Value
+
+    return Features(
+        {
+            "images": Sequence(Image()),
+            "messages": Sequence(
+                {
+                    "role": Value("string"),
+                    "content": Sequence(
+                        {
+                            "type": Value("string"),
+                            "text": Value("string"),
+                            "index": Value("int64"),
+                        }
+                    ),
+                    "reasoning_content": Value("string"),
+                    "tool_calls": Sequence(
+                        {
+                            "type": Value("string"),
+                            "function": {
+                                "name": Value("string"),
+                                "arguments": {
+                                    "action": Value("string"),
+                                    "keys": Sequence(Value("string")),
+                                    "text": Value("string"),
+                                    "coordinate": Sequence(Value("int64")),
+                                    "pixels": Value("int64"),
+                                    "time": Value("float32"),
+                                    "status": Value("string"),
+                                },
+                            },
+                        }
+                    ),
+                }
+            ),
+        }
+    )
+
+
+def main() -> None:
+    args = tyro.cli(ScriptArguments)
+
+    jsonl_path = Path(args.jsonl_path)
+    extracted_images_dir = Path(args.extracted_images_dir)
+    output_path = Path(args.output_path)
+
+    if not jsonl_path.exists():
+        raise FileNotFoundError(f"jsonl_path not found: {jsonl_path}")
+    if not extracted_images_dir.exists():
+        raise FileNotFoundError(f"extracted_images_dir not found: {extracted_images_dir}")
+
+    # If sharded, save into a deterministic shard subdir so ranks don't clobber each other.
+    if args.rank is not None and args.world_size is not None:
+        output_path = output_path / f"shard-{args.rank:05d}-of-{args.world_size:05d}"
+
+    if output_path.exists():
+        if not args.overwrite:
+            raise FileExistsError(
+                f"output_path already exists: {output_path}. Use --overwrite to replace it."
+            )
+        shutil.rmtree(output_path)
+
+    from datasets import Dataset
+
+    features = build_features()
+
+    if hasattr(Dataset, "from_generator"):
+        ds = Dataset.from_generator(
+            iter_examples,
+            gen_kwargs={
+                "jsonl_path": jsonl_path,
+                "extracted_images_dir": extracted_images_dir,
+                "rank": args.rank,
+                "world_size": args.world_size,
+            },
+        )
+    else:
+        rows = list(
+            iter_examples(
+                jsonl_path=jsonl_path,
+                extracted_images_dir=extracted_images_dir,
+                rank=args.rank,
+                world_size=args.world_size,
+            )
+        )
+        ds = Dataset.from_list(rows)
+
+    ds.save_to_disk(str(output_path))
+    print(f"Saved dataset with {len(ds)} rows to: {output_path}")
+
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+"""
+Attached file for GPT Pro
+- `agentnet_ubuntu.jsonl` (first 100 lines from `agentnet_ubuntu_5k.jsonl`)
+
+Prompt for GPT Pro:
+# Task
+Write a Python script that converts the trajectory specified in `jsonl_path`
+(an example subset is provided in `agentnet_ubuntu.jsonl`) into a HuggingFace
+dataset where each row has the following structure:
+
+# Args
+- jsonl_path (str = ".data/huggingface/xlangai/AgentNet/agentnet_ubuntu_5k.jsonl"): 
+    Path to the input JSONL file ((an example subset is provided in `agentnet_ubuntu.jsonl`)).
+- extracted_images_dir (str = ".data/huggingface/xlangai/AgentNet/extracted_ubuntu_images"): 
+    Images are stored at `{extracted_images_dir}/{traj[i].image}`.
+- output_path (str = ".data/scalecua/ubuntu"): 
+    Path to save the resulting HuggingFace dataset.
+- rank, world_size (int | None): 
+    If specified, only process a subset of `jsonl_path`.
+
+# Dataset row format
+Each dataset row must contain exactly two keys: `images` and `messages`.
+
+1) images
+~~~~~~~~~
+A list of PIL images loaded from the extracted image directory:
+
+images = [
+    PIL(f"{extracted_images_dir}/{traj[0].image}"),
+    ...
+    PIL(f"{extracted_images_dir}/{traj[n].image}")
+]
+
+2) messages
+~~~~~~~~~~~
+A multi-turn chat transcript that alternates user/assistant turns.
+- The first user turn includes image index 0 AND the high-level instruction text.
+- Each subsequent user turn includes ONLY the next image index.
+- Each assistant turn includes:
+  - reasoning_content: traj[i].value.thought
+  - content: traj[i].value.action (as plain text)
+  - tool_calls: convert traj[i].value.code (pyauto action space) -> Qwen3-VL action space
+
+messages = [
+    # Initial user instruction + first image
+    {
+        "role": "user",
+        "content": [
+            {"type": "image", "index": 0},
+            {"type": "text", "text": "{instruction}"},
+        ],
+    },
+
+    # Step 0 assistant response
+    {
+        "role": "assistant",
+        "reasoning_content": "{traj[0].value.thought}",
+        "content": [{"type": "text", "text": "{traj[0].value.action}"}],
+        # Convert raw `{traj[0].value.code}` (pyauto) -> Qwen3-VL action space
+        "tool_calls": [
+            {"type": "function", "function": {"name": "computer_use", "arguments": "..."}}
+        ],
+    },
+
+    # Step 1 user image
+    {
+        "role": "user",
+        "content": [
+            {"type": "image", "index": 1},
+        ],
+    },
+
+    # Step 1 assistant response
+    {
+        "role": "assistant",
+        "reasoning_content": "{traj[1].value.thought}",
+        "content": [{"type": "text", "text": "{traj[1].value.action}"}],
+        # Convert raw `{traj[1].value.code}` (pyauto) -> Qwen3-VL action space
+        "tool_calls": [
+            {"type": "function", "function": {"name": "computer_use", "arguments": "..."}}
+        ],
+    },
+
+    # ...
+    # Final step n
+    {
+        "role": "user",
+        "content": [
+            {"type": "image", "index": n},
+        ],
+    },
+    {
+        "role": "assistant",
+        "reasoning_content": "{traj[n].value.thought}",
+        "content": [{"type": "text", "text": "{traj[n].value.action}"}],
+        # Convert raw `{traj[n].value.code}` (pyauto) -> Qwen3-VL action space
+        "tool_calls": [
+            {"type": "function", "function": {"name": "computer_use", "arguments": "..."}}
+        ],
+    },
+]
+
+# Qwen3-VL action space
+description_prompt = "
+* `key`: Performs key down presses on the arguments passed in order, then performs key releases in reverse order.
+* `type`: Type a string of text on the keyboard.
+* `mouse_move`: Move the cursor to a specified (x, y) pixel coordinate on the screen.
+* `left_click`: Click the left mouse button at a specified (x, y) pixel coordinate on the screen.
+* `left_click_drag`: Click and drag the cursor to a specified (x, y) pixel coordinate on the screen.
+* `right_click`: Click the right mouse button at a specified (x, y) pixel coordinate on the screen.
+* `middle_click`: Click the middle mouse button at a specified (x, y) pixel coordinate on the screen.
+* `double_click`: Double-click the left mouse button at a specified (x, y) pixel coordinate on the screen.
+* `triple_click`: Triple-click the left mouse button at a specified (x, y) pixel coordinate on the screen (simulated as double-click since it's the closest action).
+* `scroll`: Performs a scroll of the mouse scroll wheel.
+* `hscroll`: Performs a horizontal scroll (mapped to regular scroll).
+* `wait`: Wait specified seconds for the change to happen.
+* `terminate`: Terminate the current task and report its completion status.
+* `answer`: Answer a question.
+** Note: all coordinates should be normalized to the range 0-1000."
+
+tools_def = {
+    "type": "function",
+    "function": {
+        "name_for_human": "computer_use",
+        "name": "computer_use",
+        "description": description_prompt,
+        "parameters": {
+            "type": "object",
+            "required": ["action"],
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "description": description_prompt,
+                    "enum": [
+                        "key",
+                        "type",
+                        "mouse_move",
+                        "left_click",
+                        "left_click_drag",
+                        "right_click",
+                        "middle_click",
+                        "double_click",
+                        "scroll",
+                        "wait",
+                        "terminate"
+                    ]
+                },
+                "keys": {"type": "array", "description": "Required only by `action=key`."},
+                "text": {"type": "string", "description": "Required only by `action=type`."},
+                "coordinate": {"type": "array", "description": "The x,y coordinates for mouse actions."},
+                "pixels": {"type": "number", "description": "The amount of scrolling."},
+                "time": {"type": "number", "description": "The seconds to wait."},
+                "status": {
+                    "type": "string",
+                    "description": "The status of the task.",
+                    "enum": ["success", "failure"]
+                }
+            }
+        },
+        "args_format": "Format the arguments as a JSON object."
+    }
+}
+
+# AgentNet → Qwen3-VL Action Mapping
+This file documents how to convert AgentNet GUI actions (`traj[n].value.code`)
+into Qwen3-VL `computer_use` tool calls.
+
+Coordinates rule:
+- AgentNet uses normalized floats `[0, 1]`
+- Qwen3-VL uses integers `[0, 1000]`
+- Convert with: `round(x * 1000), round(y * 1000)`
+
+---
+
+## (A) click → left_click
+```python
+pyautogui.click(x=0.018, y=0.508)
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "left_click",
+        "coordinate": [18, 508]
+      }
+    }
+  }]
+}
+```
+
+## (B) rightClick → right_click
+```python
+pyautogui.rightClick(x=0.304, y=0.684)
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "right_click",
+        "coordinate": [304, 684]
+      }
+    }
+  }]
+}
+```
+
+## (C) doubleClick → double_click
+```python
+pyautogui.doubleClick(x=0.153, y=0.283)
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "double_click",
+        "coordinate": [153, 283]
+      }
+    }
+  }]
+}
+```
+
+## (D) tripleClick → double_click (approx)
+```python
+computer.tripleClick(x=0.226, y=0.311)
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "double_click",
+        "coordinate": [226, 311]
+      }
+    }
+  }]
+}
+```
+
+## (E) moveTo → mouse_move
+```python
+pyautogui.moveTo(x=0.394, y=0.604)
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "mouse_move",
+        "coordinate": [394, 604]
+      }
+    }
+  }]
+}
+```
+
+## (F) moveTo + dragTo → mouse_move + left_click_drag
+```python
+pyautogui.moveTo(x=0.078, y=0.381)
+pyautogui.dragTo(x=0.085, y=0.361, button="left")
+```
+```json
+{
+  "tool_calls": [
+    {
+      "type": "function",
+      "function": {
+        "name": "computer_use",
+        "arguments": {
+          "action": "mouse_move",
+          "coordinate": [78, 381]
+        }
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "computer_use",
+        "arguments": {
+          "action": "left_click_drag",
+          "coordinate": [85, 361]
+        }
+      }
+    }
+  ]
+}
+```
+
+## (G) scroll → scroll
+```python
+pyautogui.scroll(-8)
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "scroll",
+        "pixels": -8
+      }
+    }
+  }]
+}
+```
+
+## (H) hotkey → key
+```python
+pyautogui.hotkey(["ctrl", "o"])
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "key",
+        "keys": ["ctrl", "o"]
+      }
+    }
+  }]
+}
+```
+
+## (I) press → key
+```python
+pyautogui.press("enter")
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "key",
+        "keys": ["enter"]
+      }
+    }
+  }]
+}
+```
+
+## (J) write → type
+```python
+pyautogui.write(message="cd ./Pictures")
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "type",
+        "text": "cd ./Pictures"
+      }
+    }
+  }]
+}
+```
+
+## (K) wait → wait
+```python
+computer.wait()
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "wait",
+        "time": 1.0
+      }
+    }
+  }]
+}
+```
+
+## (L) terminate → terminate
+```python
+computer.terminate(status="success")
+```
+```json
+{
+  "tool_calls": [{
+    "type": "function",
+    "function": {
+      "name": "computer_use",
+      "arguments": {
+        "action": "terminate",
+        "status": "success"
+      }
+    }
+  }]
+}
+```
+
+# Error Handling
+The script must raise a breakpoint (or exception) if:
+1. The final action in the trajectory is not terminate.
+2. Image files missing
+3. Any other parsing errors or unexpected formats occur.
+"""