5k resolved OpenHands trajectories, tool-call arguments deserialized, Qwen3-Coder-template-verified

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+sft_success.jsonl.gz.box-store-snap-6600a926e22faf88 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,122 @@
+---
+license: cc-by-4.0
+task_categories:
+  - text-generation
+tags:
+  - agent-trajectories
+  - tool-calling
+  - sft
+  - openhands
+  - swe-bench
+  - qwen3-coder
+size_categories:
+  - 1K<n<10K
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: data/train-00000-of-00001.parquet
+---
+
+# openhands-train-ready
+
+**SFT-ready normalization** of
+[nebius/SWE-rebench-openhands-trajectories](https://huggingface.co/datasets/nebius/SWE-rebench-openhands-trajectories)
+— 5,000 resolved OpenHands (v0.54.0) agent trajectories on real GitHub issues,
+bootstrapped by `Qwen/Qwen3-Coder-480B-A35B-Instruct`, with **tool-call
+arguments deserialized to objects** so chat templates just work.
+
+## What was fixed
+
+The upstream parquet stores `tool_call.function.arguments` as a serialized
+JSON *string* "for storage efficiency" (per the Nebius README). Chat templates
+that iterate `arguments|items` — including the Qwen3-Coder family — emit
+empty/broken tool calls if you train on the raw rows. Every record here has:
+
+- `arguments` deserialized `str → dict` (double-encoded JSON and Python-repr
+  dicts handled),
+- canonical per-role fields (`system`/`user`/`assistant`/`tool`),
+- the per-trajectory `tools` list kept on the record — pass it straight to
+  `apply_chat_template`.
+
+## Usage
+
+```python
+from datasets import load_dataset
+from transformers import AutoTokenizer
+
+ds = load_dataset("asaverren/openhands-train-ready", split="train")
+tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-Coder-30B-A3B-Instruct")
+
+ex = ds[0]
+text = tok.apply_chat_template(ex["messages"], tools=ex["tools"], tokenize=False)
+```
+
+TRL/axolotl: point your chat-template mapping at the `messages` column;
+`tools` is a per-row column for templates that accept it.
+
+## Qwen3-Coder tool-call format (verified)
+
+- Assistant calls render as `<tool_call><function=NAME><parameter=KEY>VALUE
+  </parameter></function></tool_call>` inside the `<|im_start|>assistant` turn.
+- `arguments` must be a mapping — the template iterates `arguments|items`.
+  (This is the upstream storage bug this dataset fixes.)
+- Tool results render as `<tool_response>...</tool_response>` inside a `user`
+  turn; `name`/`tool_call_id` are kept for provenance but unused by the template.
+
+## Counts (see `meta.json`)
+
+| | |
+|---|---|
+| upstream rows scanned | 67,074 |
+| upstream resolved | 32,161 |
+| this shard (resolved, seed-0 sample) | 5,000 |
+| tool-call arguments deserialized | 295,524 |
+| unparseable arguments | 0 |
+| unknown tools / missing required params | 0 / 0 |
+| trajectories dropped | 0 |
+| avg tokens (Qwen3-Coder tokenizer) | ≈ 49k / trajectory |
+
+Tool calls validated against upstream `tools.json` (soft; all calls match the
+5-tool OpenHands v0.54.0 set). All 5,000 records render through the real
+Qwen3-Coder chat template with zero errors.
+
+## Rebuild / extend
+
+`run_normalize.py` (+ the `traj_normalize` package, both in this repo) reproduces this shard and can emit the full 32k resolved
+set (or failure trajectories via `--include-failures`):
+
+```bash
+pip install pyarrow huggingface_hub
+python run_normalize.py --input nebius/SWE-rebench-openhands-trajectories \
+  --out-dir out --max-success 5000 --seed 0 --shuffle
+```
+
+`sft_success.jsonl.gz` is the raw tool output; `data/` is the same content as
+parquet for `load_dataset` + viewer support.
+
+## Honest limitations
+
+- `resolved` is upstream's SWE-bench-style judgment — **no re-execution
+  verification** was performed downstream.
+- Trajectories are long (~49k tokens avg); filter/truncate to your context
+  budget.
+- Single bootstrap model (Qwen3-Coder-480B) and single scaffold
+  (OpenHands v0.54.0) — behavior/diversity is bounded accordingly.
+- Same-instance duplicates are possible (upstream samples multiple attempts
+  per issue); dedupe on `instance_id` if that matters to you.
+
+## Attribution & license
+
+Upstream data: [Nebius](https://nebius.com/blog/posts/openhands-trajectories-with-qwen3-coder-480b),
+**CC-BY-4.0**. This derivative shard redistributes normalized data under the
+same license — please attribute Nebius.
+
+```bibtex
+@article{trofimova2025openhandstrajs,
+  title={OpenHands Trajectories with Qwen3-Coder-480B-A35B-Instruct},
+  author={Trofimova, Maria and Shevtsov, Anton and Ibragim, Badertdinov and Pyaev, Konstantin and Karasik, Simon and Golubev, Alexander},
+  year={2025},
+  journal={Nebius blog},
+}
+```

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee32b313863be211ba717c7806c1963a88ca54611ed2441f96afb4fd35ce6655
+size 1273663192

meta.json

@@ -0,0 +1,33 @@
+{
+  "tool": "traj-normalize",
+  "source": "nebius/SWE-rebench-openhands-trajectories",
+  "tools_schema": "/home/box/.cache/huggingface/hub/datasets--nebius--SWE-rebench-openhands-trajectories/snapshots/35455389ab51bf5e2306bfd436ef72d0f98bf882/tools.json",
+  "params": {
+    "limit": 0,
+    "max_success": 5000,
+    "max_fail": null,
+    "include_failures": false,
+    "seed": 0,
+    "shuffle": true,
+    "strict_tools": false
+  },
+  "counts": {
+    "input_rows": 67074,
+    "resolved_rows": 32161,
+    "written_success": 5000,
+    "written_fail": 0,
+    "skipped_unresolved": 34913,
+    "dropped": 0
+  },
+  "drop_reasons": {},
+  "fixes": {
+    "arguments_deserialized": 295524
+  },
+  "unknown_tools": {},
+  "missing_required_params": {},
+  "unparseable_examples": [],
+  "outputs": {
+    "sft_success.jsonl": 1311591174
+  },
+  "elapsed_sec": 51.9
+}

pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "traj-normalize"
+version = "0.1.0"
+description = "Normalize Nebius SWE-rebench OpenHands trajectories into chat-template-ready SFT messages (deserializes stringified tool-call arguments)."
+requires-python = ">=3.10"
+dependencies = [
+    "pyarrow>=15",
+    "huggingface_hub>=0.24",
+]
+
+[project.scripts]
+traj-normalize = "traj_normalize:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["traj_normalize"]

run_normalize.py

@@ -0,0 +1,6 @@
+import sys
+
+from traj_normalize.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

sft_success.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fa2d861940766aeaa077c58927c114677b64ecc2602a7f1dfe2701f11340e3a
+size 214412373

sft_success.jsonl.gz.box-store-snap-6600a926e22faf88

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fa2d861940766aeaa077c58927c114677b64ecc2602a7f1dfe2701f11340e3a
+size 214412373

tools.json

@@ -0,0 +1,185 @@
+[
+    {
+        "function": {
+            "description": "Execute a bash command in the terminal within a persistent shell session.\n\n\n### Command Execution\n* One command at a time: You can only execute one bash command at a time. If you need to run multiple commands sequentially, use `&&` or `;` to chain them together.\n* Persistent session: Commands execute in a persistent shell session where environment variables, virtual environments, and working directory persist between commands.\n* Soft timeout: Commands have a soft timeout of 10 seconds, once that's reached, you have the option to continue or interrupt the command (see section below for details)\n\n### Long-running Commands\n* For commands that may run indefinitely, run them in the background and redirect output to a file, e.g. `python3 app.py > server.log 2>&1 &`.\n* For commands that may run for a long time (e.g. installation or testing commands), or commands that run for a fixed amount of time (e.g. sleep), you should set the \"timeout\" parameter of your function call to an appropriate value.\n* If a bash command returns exit code `-1`, this means the process hit the soft timeout and is not yet finished. By setting `is_input` to `true`, you can:\n  - Send empty `command` to retrieve additional logs\n  - Send text (set `command` to the text) to STDIN of the running process\n  - Send control commands like `C-c` (Ctrl+C), `C-d` (Ctrl+D), or `C-z` (Ctrl+Z) to interrupt the process\n  - If you do C-c, you can re-start the process with a longer \"timeout\" parameter to let it run to completion\n\n### Best Practices\n* Directory verification: Before creating new directories or files, first verify the parent directory exists and is the correct location.\n* Directory management: Try to maintain working directory by using absolute paths and avoiding excessive use of `cd`.\n\n### Output Handling\n* Output truncation: If the output exceeds a maximum length, it will be truncated before being returned.\n",
+            "name": "execute_bash",
+            "parameters": {
+                "properties": {
+                    "command": {
+                        "description": "The bash command to execute. Can be empty string to view additional logs when previous exit code is `-1`. Can be `C-c` (Ctrl+C) to interrupt the currently running process. Note: You can only execute one bash command at a time. If you need to run multiple commands sequentially, you can use `&&` or `;` to chain them together.",
+                        "type": "string"
+                    },
+                    "is_input": {
+                        "description": "If True, the command is an input to the running process. If False, the command is a bash command to be executed in the terminal. Default is False.",
+                        "enum": [
+                            "true",
+                            "false"
+                        ],
+                        "type": "string"
+                    },
+                    "timeout": {
+                        "description": "Optional. Sets a hard timeout in seconds for the command execution. If not provided, the command will use the default soft timeout behavior.",
+                        "type": "number"
+                    }
+                },
+                "required": [
+                    "command"
+                ],
+                "type": "object"
+            }
+        },
+        "type": "function"
+    },
+    {
+        "function": {
+            "description": "Use the tool to think about something. It will not obtain new information or make any changes to the repository, but just log the thought. Use it when complex reasoning or brainstorming is needed.\n\nCommon use cases:\n1. When exploring a repository and discovering the source of a bug, call this tool to brainstorm several unique ways of fixing the bug, and assess which change(s) are likely to be simplest and most effective.\n2. After receiving test results, use this tool to brainstorm ways to fix failing tests.\n3. When planning a complex refactoring, use this tool to outline different approaches and their tradeoffs.\n4. When designing a new feature, use this tool to think through architecture decisions and implementation details.\n5. When debugging a complex issue, use this tool to organize your thoughts and hypotheses.\n\nThe tool simply logs your thought process for better transparency and does not execute any code or make changes.",
+            "name": "think",
+            "parameters": {
+                "properties": {
+                    "thought": {
+                        "description": "The thought to log.",
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "thought"
+                ],
+                "type": "object"
+            }
+        },
+        "type": "function"
+    },
+    {
+        "function": {
+            "description": "Signals the completion of the current task or conversation.\n\nUse this tool when:\n- You have successfully completed the user's requested task\n- You cannot proceed further due to technical limitations or missing information\n\nThe message should include:\n- A clear summary of actions taken and their results\n- Any next steps for the user\n- Explanation if you're unable to complete the task\n- Any follow-up questions if more information is needed\n",
+            "name": "finish",
+            "parameters": {
+                "properties": {
+                    "message": {
+                        "description": "Final message to send to the user",
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "message"
+                ],
+                "type": "object"
+            }
+        },
+        "type": "function"
+    },
+    {
+        "function": {
+            "description": "This tool provides structured task management capabilities for development workflows.\nIt enables systematic tracking of work items, progress monitoring, and efficient\norganization of complex development activities.\n\nThe tool maintains visibility into project status and helps communicate\nprogress effectively to users.\n\n## Application Guidelines\n\nUtilize this tool in the following situations:\n\n1. Multi-phase development work - When projects involve multiple sequential or\n   parallel activities\n2. Complex implementation tasks - Work requiring systematic planning and\n   coordination across multiple components\n3. Explicit user request for task organization - When users specifically ask\n   for structured task management\n4. Multiple concurrent requirements - When users present several work items\n   that need coordination\n5. Project initiation - Capture and organize user requirements at project start\n6. Work commencement - Update task status to in_progress before beginning\n   implementation. Maintain focus by limiting active work to one task\n7. Task completion - Update status to done and identify any additional work\n   that emerged during implementation\n\n## Situations Where Tool Usage Is Unnecessary\n\nAvoid using this tool when:\n\n1. Single atomic tasks that require no decomposition\n2. Trivial operations where tracking adds no organizational value\n3. Simple activities completable in minimal steps\n4. Pure information exchange or discussion\n\nNote: For single straightforward tasks, proceed with direct implementation\nrather than creating tracking overhead.\n\n## Usage Scenarios\n\n**Scenario A: Feature Development with Validation**\nUser request: \"Build a user authentication system with login/logout functionality.\nDon't forget to include input validation and error handling!\"\n\nResponse approach: I'll implement a user authentication system with comprehensive\nvalidation. Let me organize this work systematically.\n\n*Task breakdown includes:*\n1. Design authentication API endpoints and data models\n2. Implement user login/logout controllers with session management\n3. Add client-side form validation and error display\n4. Create backend input sanitization and security checks\n5. Implement comprehensive error handling for edge cases\n6. Perform integration testing and fix any issues\n\n**Scenario B: Codebase Refactoring**\nUser request: \"I need to update all instances of the method 'fetchData' to\n'retrieveInformation' throughout the entire project\"\n\nResponse approach: Let me first analyze your codebase to identify all locations\nwhere 'fetchData' appears.\n\n*After code analysis*\n\nI've located 12 occurrences of 'fetchData' across 6 files in your project.\nI'll create a systematic plan to update these references.\n\n*Organized task list includes specific file-by-file updates*\n\n**Scenario C: Multi-feature Development**\nUser request: \"Set up a blog platform with these components: admin dashboard,\narticle management, comment system, and user profiles.\"\n\nResponse approach: I'll help build your blog platform. Let me break down these\ncomponents into manageable implementation phases.\n\n*Creates structured plan with each feature decomposed into specific development tasks*\n\n## Counter-examples - Direct Implementation Preferred\n\n**Counter-example A: Simple inquiry**\nUser request: \"What's the syntax for a for loop in JavaScript?\"\n\nResponse approach: Here's how to write a for loop in JavaScript:\n\n```javascript\nfor (let i = 0; i < array.length; i++) {\n    console.log(array[i]);\n}\n```\n\n*No task tracking needed - single informational response*\n\n**Counter-example B: Minor modification**\nUser request: \"Please add a docstring to the processPayment function explaining\nits parameters.\"\n\nResponse approach: I'll add a docstring to explain the processPayment function.\n\n*Direct edit without task tracking for simple modification*\n\n## Status Management and Workflow\n\n1. **Status Values**: Track work using these states:\n   - todo: Not yet initiated\n   - in_progress: Currently active (maintain single focus)\n   - done: Successfully completed\n\n2. **Workflow Practices**:\n   - Update status dynamically as work progresses\n   - Mark completion immediately upon task finish\n   - Limit active work to ONE task at any given time\n   - Complete current activities before initiating new ones\n   - Remove obsolete tasks from tracking entirely\n\n3. **Completion Criteria**:\n   - Mark tasks as done only when fully achieved\n   - Keep status as in_progress if errors, blocks, or partial completion exist\n   - Create new tasks for discovered issues or dependencies\n   - Never mark done when:\n       - Test suites are failing\n       - Implementation remains incomplete\n       - Unresolved errors persist\n       - Required resources are unavailable\n\n4. **Task Organization**:\n   - Write precise, actionable descriptions\n   - Decompose complex work into manageable units\n   - Use descriptive, clear naming conventions\n\nWhen uncertain, favor using this tool. Proactive task management demonstrates\nsystematic approach and ensures comprehensive requirement fulfillment.\n",
+            "name": "task_tracker",
+            "parameters": {
+                "additionalProperties": false,
+                "properties": {
+                    "command": {
+                        "description": "The command to execute. `view` shows the current task list. `plan` creates or updates the task list based on provided requirements and progress. Always `view` the current list before making changes.",
+                        "enum": [
+                            "view",
+                            "plan"
+                        ],
+                        "type": "string"
+                    },
+                    "task_list": {
+                        "description": "The full task list. Required parameter of `plan` command.",
+                        "items": {
+                            "additionalProperties": false,
+                            "properties": {
+                                "id": {
+                                    "description": "Unique task identifier",
+                                    "type": "string"
+                                },
+                                "notes": {
+                                    "description": "Optional additional context or details",
+                                    "type": "string"
+                                },
+                                "status": {
+                                    "description": "Current task status",
+                                    "enum": [
+                                        "todo",
+                                        "in_progress",
+                                        "done"
+                                    ],
+                                    "type": "string"
+                                },
+                                "title": {
+                                    "description": "Brief task description",
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "title",
+                                "status",
+                                "id"
+                            ],
+                            "type": "object"
+                        },
+                        "type": "array"
+                    }
+                },
+                "required": [
+                    "command"
+                ],
+                "type": "object"
+            }
+        },
+        "type": "function"
+    },
+    {
+        "function": {
+            "description": "Custom editing tool for viewing, creating and editing files in plain-text format\n* State is persistent across command calls and discussions with the user\n* If `path` is a text file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep\n* The following binary file extensions can be viewed in Markdown format: [\".xlsx\", \".pptx\", \".wav\", \".mp3\", \".m4a\", \".flac\", \".pdf\", \".docx\"]. IT DOES NOT HANDLE IMAGES.\n* The `create` command cannot be used if the specified `path` already exists as a file\n* If a `command` generates a long output, it will be truncated and marked with `<response clipped>`\n* The `undo_edit` command will revert the last edit made to the file at `path`\n* This tool can be used for creating and editing files in plain-text format.\n\n\nBefore using this tool:\n1. Use the view tool to understand the file's contents and context\n2. Verify the directory path is correct (only applicable when creating new files):\n   - Use the view tool to verify the parent directory exists and is the correct location\n\nWhen making edits:\n   - Ensure the edit results in idiomatic, correct code\n   - Do not leave the code in a broken state\n   - Always use absolute file paths (starting with /)\n\nCRITICAL REQUIREMENTS FOR USING THIS TOOL:\n\n1. EXACT MATCHING: The `old_str` parameter must match EXACTLY one or more consecutive lines from the file, including all whitespace and indentation. The tool will fail if `old_str` matches multiple locations or doesn't match exactly with the file content.\n\n2. UNIQUENESS: The `old_str` must uniquely identify a single instance in the file:\n   - Include sufficient context before and after the change point (3-5 lines recommended)\n   - If not unique, the replacement will not be performed\n\n3. REPLACEMENT: The `new_str` parameter should contain the edited lines that replace the `old_str`. Both strings must be different.\n\nRemember: when making multiple file edits in a row to the same file, you should prefer to send all edits in a single message with multiple calls to this tool, rather than multiple messages with a single call each.\n",
+            "name": "str_replace_editor",
+            "parameters": {
+                "properties": {
+                    "command": {
+                        "description": "The commands to run. Allowed options are: `view`, `create`, `str_replace`, `insert`, `undo_edit`.",
+                        "enum": [
+                            "view",
+                            "create",
+                            "str_replace",
+                            "insert",
+                            "undo_edit"
+                        ],
+                        "type": "string"
+                    },
+                    "file_text": {
+                        "description": "Required parameter of `create` command, with the content of the file to be created.",
+                        "type": "string"
+                    },
+                    "insert_line": {
+                        "description": "Required parameter of `insert` command. The `new_str` will be inserted AFTER the line `insert_line` of `path`.",
+                        "type": "integer"
+                    },
+                    "new_str": {
+                        "description": "Optional parameter of `str_replace` command containing the new string (if not given, no string will be added). Required parameter of `insert` command containing the string to insert.",
+                        "type": "string"
+                    },
+                    "old_str": {
+                        "description": "Required parameter of `str_replace` command containing the string in `path` to replace.",
+                        "type": "string"
+                    },
+                    "path": {
+                        "description": "Absolute path to file or directory, e.g. `/workspace/file.py` or `/workspace`.",
+                        "type": "string"
+                    },
+                    "view_range": {
+                        "description": "Optional parameter of `view` command when `path` points to a file. If none is given, the full file is shown. If provided, the file will be shown in the indicated line number range, e.g. [11, 12] will show lines 11 and 12. Indexing at 1 to start. Setting `[start_line, -1]` shows all lines from `start_line` to the end of the file.",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "type": "array"
+                    }
+                },
+                "required": [
+                    "command",
+                    "path"
+                ],
+                "type": "object"
+            }
+        },
+        "type": "function"
+    }
+]

traj_normalize/__init__.py

@@ -0,0 +1,7 @@
+"""traj-normalize: Nebius OpenHands trajectories -> SFT-ready messages."""
+
+from .core import Stats, load_tools_schema, normalize_row, row_to_record
+from .cli import main
+
+__all__ = ["Stats", "load_tools_schema", "normalize_row", "row_to_record", "main"]
+__version__ = "0.1.0"

traj_normalize/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

traj_normalize/cli.py

@@ -0,0 +1,228 @@
+"""traj-normalize CLI: Nebius OpenHands parquet -> SFT-ready jsonl.
+
+Usage:
+    traj-normalize --input nebius/SWE-rebench-openhands-trajectories \
+        --out-dir out --max-success 5000 --seed 0
+    traj-normalize --input /path/to/trajectories.parquet --out-dir out
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import sys
+import time
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+from .core import Stats, load_tools_schema, normalize_row, row_to_record
+
+META_COLS = ["trajectory_id", "instance_id", "repo", "resolved"]
+DEFAULT_REPO = "nebius/SWE-rebench-openhands-trajectories"
+DEFAULT_DATA_FILE = "trajectories.parquet"
+
+
+def resolve_input(inp: str) -> tuple[Path, str]:
+    """Return (parquet_path, source_desc). Downloads from the Hub if needed."""
+    p = Path(inp)
+    if p.is_file():
+        return p, str(p.resolve())
+    from huggingface_hub import hf_hub_download
+
+    path = hf_hub_download(repo_id=inp, repo_type="dataset", filename=DEFAULT_DATA_FILE)
+    return Path(path), inp
+
+
+def resolve_tools_json(tools_arg: str | None, source: str) -> str | None:
+    if tools_arg:
+        return tools_arg
+    # If input came from the Hub, try to fetch tools.json from the same repo.
+    if not Path(source).is_file():
+        try:
+            from huggingface_hub import hf_hub_download
+
+            return hf_hub_download(repo_id=source, repo_type="dataset", filename="tools.json")
+        except Exception:
+            return None
+    # Local file: look for tools.json next to the parquet.
+    cand = Path(source).parent / "tools.json"
+    return str(cand) if cand.exists() else None
+
+
+def pass1_select_indices(pf: pq.ParquetFile, args) -> tuple[set[int], Stats]:
+    """Scan light columns; return selected row indices + populated counters."""
+    stats = Stats()
+    resolved_idx, fail_idx = [], []
+    offset = 0
+    for batch in pf.iter_batches(batch_size=args.batch_size, columns=META_COLS):
+        for row in batch.to_pylist():
+            stats.input_rows += 1
+            if row.get("resolved") == 1:
+                stats.resolved_rows += 1
+                resolved_idx.append(offset)
+            else:
+                fail_idx.append(offset)
+            offset += 1
+            if args.limit and stats.input_rows >= args.limit:
+                break
+        if args.limit and stats.input_rows >= args.limit:
+            break
+
+    rng = random.Random(args.seed)
+    if args.max_success and len(resolved_idx) > args.max_success:
+        resolved_idx = sorted(rng.sample(resolved_idx, args.max_success))
+    if args.include_failures:
+        if args.max_fail and len(fail_idx) > args.max_fail:
+            fail_idx = sorted(rng.sample(fail_idx, args.max_fail))
+    else:
+        fail_idx = []
+
+    selected = set(resolved_idx) | set(fail_idx)
+    return selected, stats
+
+
+def run(args) -> int:
+    parquet_path, source = resolve_input(args.input)
+    tools_path = resolve_tools_json(args.tools_json, source)
+    tools_schema = load_tools_schema(tools_path)
+    if args.tools_json and tools_schema is None:
+        print(f"warning: could not load tools schema from {args.tools_json}", file=sys.stderr)
+
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    success_path = out_dir / "sft_success.jsonl"
+    fail_path = out_dir / "sft_fail.jsonl"
+    meta_path = out_dir / "meta.json"
+
+    pf = pq.ParquetFile(parquet_path)
+    t0 = time.time()
+
+    selected, stats = pass1_select_indices(pf, args)
+    print(f"scanned {stats.input_rows} rows ({stats.resolved_rows} resolved); "
+          f"selected {len(selected)} for extraction", file=sys.stderr)
+
+    # Pass 2: full rows for selected indices.
+    records = [] if args.shuffle else None
+    f_succ = open(success_path, "w")
+    f_fail = open(fail_path, "w") if args.include_failures else None
+    offset = 0
+    try:
+        for batch in pf.iter_batches(batch_size=args.batch_size):
+            for row in batch.to_pylist():
+                idx = offset
+                offset += 1
+                if args.limit and idx >= args.limit:
+                    break
+                if idx not in selected:
+                    continue
+                messages, err = normalize_row(row, stats, tools_schema, args.strict_tools)
+                if err:
+                    stats.drop(err)
+                    continue
+                rec = row_to_record(row, messages, emit_tools=not args.no_tools)
+                if records is not None:
+                    records.append(rec)
+                else:
+                    (f_succ if rec["resolved"] == 1 else f_fail).write(
+                        json.dumps(rec, ensure_ascii=False) + "\n")
+                if rec["resolved"] == 1:
+                    stats.written_success += 1
+                else:
+                    stats.written_fail += 1
+            if args.limit and offset >= args.limit:
+                break
+
+        if records is not None:
+            rng = random.Random(args.seed)
+            rng.shuffle(records)
+            stats.written_success = stats.written_fail = 0
+            for rec in records:
+                (f_succ if rec["resolved"] == 1 else f_fail).write(
+                    json.dumps(rec, ensure_ascii=False) + "\n")
+                if rec["resolved"] == 1:
+                    stats.written_success += 1
+                else:
+                    stats.written_fail += 1
+    finally:
+        f_succ.close()
+        if f_fail:
+            f_fail.close()
+
+    if not args.include_failures and fail_path.exists():
+        fail_path.unlink()
+
+    stats.skipped_unresolved = stats.input_rows - stats.resolved_rows
+
+    meta = {
+        "tool": "traj-normalize",
+        "source": source,
+        "tools_schema": tools_path if tools_schema else None,
+        "params": {
+            "limit": args.limit,
+            "max_success": args.max_success,
+            "max_fail": args.max_fail if args.include_failures else None,
+            "include_failures": args.include_failures,
+            "seed": args.seed,
+            "shuffle": args.shuffle,
+            "strict_tools": args.strict_tools,
+        },
+        "counts": {
+            "input_rows": stats.input_rows,
+            "resolved_rows": stats.resolved_rows,
+            "written_success": stats.written_success,
+            "written_fail": stats.written_fail,
+            "skipped_unresolved": stats.skipped_unresolved,
+            "dropped": sum(stats.drop_reasons.values()),
+        },
+        "drop_reasons": stats.drop_reasons,
+        "fixes": stats.fixes,
+        "unknown_tools": stats.unknown_tools,
+        "missing_required_params": stats.missing_required_params,
+        "unparseable_examples": stats.unparseable_examples,
+        "outputs": {
+            p.name: p.stat().st_size for p in (success_path, fail_path) if p.exists()
+        },
+        "elapsed_sec": round(time.time() - t0, 1),
+    }
+    meta_path.write_text(json.dumps(meta, indent=2, ensure_ascii=False))
+    print(json.dumps(meta["counts"], indent=2), file=sys.stderr)
+    print(f"wrote {success_path} (+meta {meta_path})", file=sys.stderr)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    ap = argparse.ArgumentParser(
+        prog="traj-normalize",
+        description="Deserialize Nebius OpenHands trajectories into SFT-ready message lists.",
+    )
+    ap.add_argument("--input", default=DEFAULT_REPO,
+                    help="Local parquet path or HF dataset repo id (default: %(default)s)")
+    ap.add_argument("--out-dir", default="out")
+    ap.add_argument("--tools-json", default=None,
+                    help="Path to upstream tools.json for soft validation (auto-fetched for Hub input)")
+    ap.add_argument("--limit", type=int, default=0, help="Max input rows to scan (0 = all)")
+    ap.add_argument("--max-success", type=int, default=0,
+                    help="Cap on resolved trajectories written (0 = all). Random sample with --seed.")
+    ap.add_argument("--include-failures", action="store_true",
+                    help="Also write unresolved trajectories to sft_fail.jsonl")
+    ap.add_argument("--max-fail", type=int, default=0, help="Cap on failure trajectories (0 = all)")
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--shuffle", action="store_true",
+                    help="Shuffle output records (buffers selected rows in memory)")
+    ap.add_argument("--strict-tools", action="store_true",
+                    help="Drop trajectories calling tools absent from tools.json")
+    ap.add_argument("--no-tools", action="store_true",
+                    help="Do not embed the per-row tool list in each record")
+    ap.add_argument("--batch-size", type=int, default=32)
+    return ap
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    return run(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

traj_normalize/core.py

@@ -0,0 +1,219 @@
+"""Core normalization logic for Nebius SWE-rebench OpenHands trajectories.
+
+The upstream parquet stores ``tool_call.function.arguments`` as a *serialized
+JSON string*. Chat templates (e.g. Qwen3-Coder) iterate ``arguments|items`` and
+therefore require a mapping -- feeding the raw string produces empty or broken
+tool calls at train/infer time. This module deserializes arguments, canonicalizes
+message fields per role, and optionally validates tool calls against the
+upstream ``tools.json``.
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+from dataclasses import dataclass, field
+from typing import Any, Iterable, Optional
+
+# Canonical per-role fields, mirroring the upstream README's role2field_names.
+ROLE_FIELDS = {
+    "system": ("role", "content"),
+    "user": ("role", "content"),
+    "assistant": ("role", "content", "tool_calls"),
+    "tool": ("role", "content", "name", "tool_call_id"),
+}
+KNOWN_ROLES = frozenset(ROLE_FIELDS)
+
+
+@dataclass
+class Stats:
+    """Accumulates fix/drop counters; serialized into meta.json."""
+
+    input_rows: int = 0
+    resolved_rows: int = 0
+    written_success: int = 0
+    written_fail: int = 0
+    skipped_unresolved: int = 0
+    drop_reasons: dict = field(default_factory=dict)
+    fixes: dict = field(default_factory=dict)
+    unknown_tools: dict = field(default_factory=dict)
+    missing_required_params: dict = field(default_factory=dict)
+    unparseable_examples: list = field(default_factory=list)
+
+    def bump(self, bucket: dict, key: str, n: int = 1) -> None:
+        bucket[key] = bucket.get(key, 0) + n
+
+    def drop(self, reason: str) -> None:
+        self.bump(self.drop_reasons, reason)
+
+    def fix(self, kind: str, n: int = 1) -> None:
+        self.bump(self.fixes, kind, n)
+
+
+def load_tools_schema(path: Optional[str]) -> Optional[dict]:
+    """Load an OpenAI-style tools.json -> {name: {required: set, properties: set}}."""
+    if not path:
+        return None
+    with open(path) as f:
+        tools = json.load(f)
+    schema = {}
+    for entry in tools:
+        fn = entry.get("function", entry)
+        name = fn.get("name")
+        if not name:
+            continue
+        params = fn.get("parameters") or {}
+        schema[name] = {
+            "required": set(params.get("required") or []),
+            "properties": set((params.get("properties") or {}).keys()),
+        }
+    return schema
+
+
+def deserialize_arguments(raw: Any, stats: Stats) -> tuple[Optional[dict], Optional[str]]:
+    """Return (arguments_dict, drop_reason). arguments_dict is None on failure."""
+    if raw is None:
+        stats.fix("missing_arguments")
+        return {}, None
+    if isinstance(raw, dict):
+        return raw, None
+    if not isinstance(raw, str):
+        return None, "arguments_not_object"
+
+    value: Any = raw
+    rounds = 0
+    while isinstance(value, str):
+        rounds += 1
+        if rounds > 3:
+            return None, "arguments_unparseable"
+        try:
+            value = json.loads(value)
+        except (json.JSONDecodeError, ValueError):
+            try:
+                value = ast.literal_eval(value)
+                stats.fix("literal_eval_fallback")
+            except (ValueError, SyntaxError, MemoryError):
+                snippet = value[:200] if isinstance(value, str) else repr(value)[:200]
+                if len(stats.unparseable_examples) < 5:
+                    stats.unparseable_examples.append(snippet)
+                return None, "arguments_unparseable"
+    if rounds > 1:
+        stats.fix("double_encoded_arguments")
+    stats.fix("arguments_deserialized")
+    if not isinstance(value, dict):
+        return None, "arguments_not_object"
+    return value, None
+
+
+def normalize_tool_call(tc: Any, stats: Stats) -> tuple[Optional[dict], Optional[str]]:
+    """Normalize one tool call to {"id"?, "type"?, "function": {"name", "arguments": dict}}."""
+    if not isinstance(tc, dict):
+        return None, "tool_call_not_object"
+
+    # Some producers put name/arguments at the top level instead of under "function".
+    fn = tc.get("function") if isinstance(tc.get("function"), dict) else None
+    if fn is None:
+        if "name" in tc or "arguments" in tc:
+            fn = {"name": tc.get("name"), "arguments": tc.get("arguments")}
+            stats.fix("flattened_tool_call")
+        else:
+            return None, "tool_call_missing_function"
+
+    args, err = deserialize_arguments(fn.get("arguments"), stats)
+    if err:
+        return None, err
+
+    out = {"type": tc.get("type", "function"),
+           "function": {"name": fn.get("name"), "arguments": args}}
+    if tc.get("id") is not None:
+        out["id"] = tc["id"]
+    return out, None
+
+
+def normalize_message(msg: Any, stats: Stats) -> tuple[Optional[dict], Optional[str]]:
+    if not isinstance(msg, dict):
+        return None, "message_not_object"
+    role = msg.get("role")
+    if role not in KNOWN_ROLES:
+        return None, f"unknown_role:{role}"
+
+    out = {k: msg.get(k) for k in ROLE_FIELDS[role] if msg.get(k) is not None or k in ("role", "content")}
+
+    if role == "assistant":
+        tcs = msg.get("tool_calls")
+        if tcs:
+            norm = []
+            for tc in tcs:
+                ntc, err = normalize_tool_call(tc, stats)
+                if err:
+                    return None, err
+                norm.append(ntc)
+            out["tool_calls"] = norm
+        else:
+            out.pop("tool_calls", None)
+    return out, None
+
+
+def validate_against_tools(messages: Iterable[dict], schema: dict, stats: Stats) -> int:
+    """Soft validation: count tool calls whose name or required params are off.
+
+    Returns the number of calls in *these* messages using an unknown tool name.
+    """
+    unknown = 0
+    for msg in messages:
+        if msg.get("role") != "assistant":
+            continue
+        for tc in msg.get("tool_calls") or []:
+            fn = tc.get("function", {})
+            name = fn.get("name")
+            spec = schema.get(name)
+            if spec is None:
+                stats.bump(stats.unknown_tools, str(name))
+                unknown += 1
+                continue
+            missing = spec["required"] - set((fn.get("arguments") or {}).keys())
+            for p in missing:
+                stats.bump(stats.missing_required_params, f"{name}:{p}")
+    return unknown
+
+
+def normalize_row(row: dict, stats: Stats, tools_schema: Optional[dict] = None,
+                  strict_tools: bool = False) -> tuple[Optional[list], Optional[str]]:
+    """Normalize one parquet row -> messages list, or (None, drop_reason)."""
+    traj = row.get("trajectory")
+    if not traj:
+        return None, "empty_trajectory"
+
+    messages = []
+    for msg in traj:
+        nm, err = normalize_message(msg, stats)
+        if err:
+            return None, err
+        messages.append(nm)
+
+    if not any(m["role"] == "assistant" for m in messages):
+        return None, "no_assistant_messages"
+
+    if tools_schema:
+        n_unknown = validate_against_tools(messages, tools_schema, stats)
+        if strict_tools and n_unknown:
+            return None, "unknown_tool"
+
+    return messages, None
+
+
+def row_to_record(row: dict, messages: list, emit_tools: bool = True) -> dict:
+    rec = {
+        "messages": messages,
+        "trajectory_id": row.get("trajectory_id"),
+        "instance_id": row.get("instance_id"),
+        "repo": row.get("repo"),
+        "resolved": int(row.get("resolved") or 0),
+        "exit_status": row.get("exit_status"),
+        "model_patch": row.get("model_patch"),
+        "gen_tests_correct": row.get("gen_tests_correct"),
+        "pred_passes_gen_tests": row.get("pred_passes_gen_tests"),
+    }
+    if emit_tools and row.get("tools"):
+        rec["tools"] = row["tools"]
+    return rec