Stage Harbor release files 4001-4500

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/sft_gemma3.py

@@ -0,0 +1,69 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+#     "trl",
+#     "Pillow",
+#     "trackio",
+#     "kernels",
+# ]
+# ///
+
+"""
+Train Gemma-3 on the Codeforces COTS dataset.
+
+accelerate launch --config_file examples/accelerate_configs/deepspeed_zero3.yaml examples/scripts/sft_gemma3.py
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForImageTextToText
+
+from trl import SFTConfig, SFTTrainer
+
+
+def main():
+    # Load dataset
+    train_dataset = load_dataset("open-r1/codeforces-cots", split="train")
+    train_dataset = train_dataset.remove_columns("prompt")
+
+    # Load model
+    model_id = "google/gemma-3-12b-it"
+    model = AutoModelForImageTextToText.from_pretrained(model_id, attn_implementation="eager")
+
+    # Train model
+    training_args = SFTConfig(
+        output_dir=f"{model_id}-codeforces-SFT",
+        bf16=True,
+        use_liger_kernel=True,
+        max_length=8192,
+        per_device_train_batch_size=1,
+        gradient_accumulation_steps=8,
+        dataset_num_proc=32,
+        num_train_epochs=1,
+    )
+
+    trainer = SFTTrainer(
+        args=training_args,
+        model=model,
+        train_dataset=train_dataset,
+    )
+    trainer.train()
+
+    # Push to hub
+    trainer.push_to_hub(dataset_name="open-r1/codeforces-cots")
+
+
+if __name__ == "__main__":
+    main()

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/sft_gpt_oss.py

@@ -0,0 +1,92 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+#     "trl",
+#     "kernels",
+#     "trackio",
+#     "kernels",
+# ]
+# ///
+
+"""
+pip install –-upgrade kernels
+
+Example:
+
+accelerate launch \
+    --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+    examples/scripts/sft_gpt_oss.py \
+    --dtype bfloat16 \
+    --model_name_or_path openai/gpt-oss-20b \
+    --packing \
+    --run_name 20b-full-eager \
+    --attn_implementation kernels-community/vllm-flash-attn3 \
+    --dataset_num_proc 12 \
+    --dataset_name HuggingFaceH4/Multilingual-Thinking \
+    --max_length 4096 \
+    --per_device_train_batch_size 2 \
+    --num_train_epochs 1 \
+    --logging_steps 1 \
+    --warmup_steps 0.03 \
+    --lr_scheduler_type cosine_with_min_lr \
+    --lr_scheduler_kwargs '{"min_lr_rate": 0.1}' \
+    --output_dir gpt-oss-20b-multilingual-reasoner \
+    --report_to trackio \
+    --seed 42
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, Mxfp4Config
+
+from trl import ModelConfig, ScriptArguments, SFTConfig, SFTTrainer, TrlParser, get_peft_config
+
+
+def main(script_args, training_args, model_args):
+    # Load model
+    quantization_config = Mxfp4Config(dequantize=True)
+    model_kwargs = dict(
+        revision=model_args.model_revision,
+        trust_remote_code=model_args.trust_remote_code,
+        attn_implementation=model_args.attn_implementation,
+        dtype=model_args.dtype,
+        use_cache=False if training_args.gradient_checkpointing else True,
+        quantization_config=quantization_config,
+    )
+
+    model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+    # Load dataset
+    dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+    # Train model
+    trainer = SFTTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset[script_args.dataset_train_split],
+        eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+        peft_config=get_peft_config(model_args),
+    )
+
+    trainer.train()
+    trainer.save_model(training_args.output_dir)
+    if training_args.push_to_hub:
+        trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+
+if __name__ == "__main__":
+    parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
+    script_args, training_args, model_args, _ = parser.parse_args_and_config(return_remaining_strings=True)
+    main(script_args, training_args, model_args)

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/sft_nemotron_3.py

@@ -0,0 +1,116 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+#     "trl[peft,quantization]",
+#     "transformers>=5.3.0",
+#     "trackio",
+#     "mamba_ssm==2.2.5",
+#     "causal_conv1d==1.5.2",
+# ]
+# ///
+
+"""
+Fine-tune NVIDIA Nemotron 3 models with SFT.
+
+Prerequisites:
+
+    pip install "transformers>=5.3.0"
+    pip install --no-build-isolation mamba_ssm==2.2.5
+    pip install --no-build-isolation causal_conv1d==1.5.2
+
+Example:
+
+accelerate launch \
+    --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+    examples/scripts/sft_nemotron_3.py \
+    --dtype bfloat16 \
+    --model_name_or_path nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16 \
+    --attn_implementation eager \
+    --dataset_name HuggingFaceH4/Multilingual-Thinking \
+    --max_length 128 \
+    --per_device_train_batch_size 1 \
+    --gradient_accumulation_steps 4 \
+    --num_train_epochs 1 \
+    --learning_rate 2e-4 \
+    --optim paged_adamw_8bit \
+    --logging_steps 10 \
+    --output_dir nemotron-3-sft \
+    --report_to trackio \
+    --use_peft \
+    --lora_r 8 \
+    --lora_alpha 16 \
+    --lora_target_modules q_proj k_proj v_proj o_proj gate_proj up_proj down_proj
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM
+
+from trl import ModelConfig, ScriptArguments, SFTConfig, SFTTrainer, TrlParser, get_peft_config
+
+
+def main(script_args, training_args, model_args):
+    # NemotronH does not support gradient checkpointing
+    training_args.gradient_checkpointing = False
+
+    # Load model
+    model_kwargs = dict(
+        revision=model_args.model_revision,
+        attn_implementation=model_args.attn_implementation,
+        dtype=model_args.dtype,
+    )
+    model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+    # Load dataset
+    dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+    # Merge thinking into message content using <think> tags and remove extra columns
+    def merge_thinking_and_remove_key(example):
+        new_messages = []
+        for msg in example["messages"]:
+            content = msg["content"]
+            thinking = msg.get("thinking")
+            if thinking and isinstance(thinking, str) and thinking.strip():
+                content = f"<think>\n{thinking}\n</think>\n{content}"
+            new_messages.append({"role": msg["role"], "content": content})
+        example["messages"] = new_messages
+        return example
+
+    dataset = dataset.map(merge_thinking_and_remove_key)
+
+    # Prepare eval dataset if needed
+    eval_dataset = None
+    if training_args.eval_strategy != "no" and script_args.dataset_test_split in dataset:
+        eval_dataset = dataset[script_args.dataset_test_split]
+
+    # Train model
+    trainer = SFTTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset[script_args.dataset_train_split],
+        eval_dataset=eval_dataset,
+        peft_config=get_peft_config(model_args),
+    )
+
+    trainer.train()
+    trainer.save_model(training_args.output_dir)
+    if training_args.push_to_hub:
+        trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+
+if __name__ == "__main__":
+    parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
+    script_args, training_args, model_args, _ = parser.parse_args_and_config(return_remaining_strings=True)
+    main(script_args, training_args, model_args)

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/sft_tiny_aya_tool_calling.py

@@ -0,0 +1,164 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+#     "trl[peft]",
+#     "bitsandbytes",
+#     "liger-kernel",
+#     "trackio",
+# ]
+# ///
+
+"""
+Teach tool calling to CohereLabs/tiny-aya-global using SFT with QLoRA on the bebechien/SimpleToolCalling dataset.
+
+The model used in this script does not have native tool-calling support. We extend its existing Jinja2 chat template to
+serialize tool schemas into the system preamble and render tool calls as structured <tool_call> XML inside the model's
+native <|START_RESPONSE|> / <|END_RESPONSE|> delimiters. The modified template is saved with the tokenizer, so
+inference only requires loading the tokenizer from the output directory and calling apply_chat_template with
+tools=TOOLS — no manual system-prompt construction needed.
+
+Example:
+
+    python examples/scripts/sft_tiny_aya_tool_calling.py
+"""
+
+import json
+from pathlib import Path
+
+import torch
+from datasets import load_dataset
+from peft import LoraConfig
+from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+
+from trl import SFTConfig, SFTTrainer
+
+
+# These are the tool schemas that are used in the dataset
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "search_knowledge_base",
+            "description": "Search internal company documents, policies and project data.",
+            "parameters": {
+                "type": "object",
+                "properties": {"query": {"type": "string", "description": "query string"}},
+                "required": ["query"],
+            },
+            "return": {"type": "string"},
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "search_google",
+            "description": "Search public information.",
+            "parameters": {
+                "type": "object",
+                "properties": {"query": {"type": "string", "description": "query string"}},
+                "required": ["query"],
+            },
+            "return": {"type": "string"},
+        },
+    },
+]
+
+
+def create_conversation(sample):
+    return {
+        "prompt": [{"role": "user", "content": sample["user_content"]}],
+        "completion": [
+            {
+                "role": "assistant",
+                "tool_calls": [
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": sample["tool_name"],
+                            "arguments": json.loads(sample["tool_arguments"]),
+                        },
+                    }
+                ],
+            },
+        ],
+        "tools": TOOLS,
+    }
+
+
+def main():
+    model_id = "CohereLabs/tiny-aya-global"
+    dataset_name = "bebechien/SimpleToolCalling"
+    output_dir = "tiny-aya-global-tool-calling-SFT"
+
+    # Load and format dataset
+    dataset = load_dataset(dataset_name, split="train")
+    dataset = dataset.map(create_conversation, remove_columns=dataset.features)
+    dataset = dataset.train_test_split(test_size=0.5, shuffle=True)
+
+    # Load model
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id,
+        attn_implementation="sdpa",
+        dtype=torch.float16,
+        quantization_config=BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+        ),
+    )
+
+    # Configure LoRA
+    peft_config = LoraConfig(
+        r=32,
+        lora_alpha=32,
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+    )
+
+    # Train
+    training_args = SFTConfig(
+        output_dir=output_dir,
+        per_device_train_batch_size=1,
+        gradient_accumulation_steps=4,
+        # Use the tool-aware chat template
+        chat_template_path=str(Path(__file__).parent / "tiny_aya_chat_template.jinja"),
+        warmup_steps=5,
+        learning_rate=2e-4,
+        optim="paged_adamw_8bit",
+        logging_steps=1,
+        report_to="trackio",
+        trackio_space_id=output_dir,
+        max_length=1024,
+        use_liger_kernel=True,
+        activation_offloading=True,
+        push_to_hub=True,
+    )
+
+    trainer = SFTTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset["train"],
+        peft_config=peft_config,
+    )
+    trainer.train()
+
+    # Save model and tokenizer (tokenizer carries the updated chat template)
+    trainer.save_model(output_dir)
+    trainer.push_to_hub(dataset_name=dataset_name)
+
+
+if __name__ == "__main__":
+    main()

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/sft_video_llm.py

@@ -0,0 +1,248 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+#     "trl[peft]",
+#     "qwen-vl-utils",
+#     "torchvision",
+#     "bitsandbytes",
+#     "trackio",
+#     "kernels",
+# ]
+# ///
+
+"""
+Example usage:
+accelerate launch \
+    --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
+    examples/scripts/sft_video_llm.py \
+    --dataset_name mfarre/simplevideoshorts \
+    --video_cache_dir "/optional/path/to/cache/" \
+    --model_name_or_path Qwen/Qwen2-VL-7B-Instruct \
+    --per_device_train_batch_size 1 \
+    --output_dir video-llm-output \
+    --tf32 True \
+    --gradient_accumulation_steps 4 \
+    --num_train_epochs 4 \
+    --optim adamw_torch_fused \
+    --log_level debug \
+    --log_level_replica debug \
+    --save_strategy steps \
+    --save_steps 300 \
+    --learning_rate 8e-5 \
+    --max_grad_norm 0.3 \
+    --warmup_steps 0.1 \
+    --lr_scheduler_type cosine \
+    --push_to_hub False \
+    --dtype bfloat16
+"""
+
+import json
+import os
+import random
+from dataclasses import dataclass, field
+from typing import Any
+
+import requests
+import torch
+from datasets import load_dataset
+from peft import LoraConfig
+from qwen_vl_utils import process_vision_info
+from transformers import AutoModelForImageTextToText, AutoProcessor, BitsAndBytesConfig, Qwen2VLProcessor
+
+from trl import ModelConfig, ScriptArguments, SFTConfig, SFTTrainer, TrlParser, get_kbit_device_map
+
+
+def download_video(url: str, cache_dir: str) -> str:
+    """Download video if not already present locally."""
+    os.makedirs(cache_dir, exist_ok=True)  # Create cache dir if it doesn't exist
+    filename = url.split("/")[-1]
+    local_path = os.path.join(cache_dir, filename)
+
+    if os.path.exists(local_path):
+        return local_path
+
+    try:
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(local_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+        return local_path
+    except requests.RequestException as e:
+        raise Exception(f"Failed to download video: {e}") from e
+
+
+def prepare_dataset(example: dict[str, Any], cache_dir: str) -> dict[str, list[dict[str, Any]]]:
+    """Prepare dataset example for training."""
+    video_url = example["video_url"]
+    timecoded_cc = example["timecoded_cc"]
+    qa_pairs = json.loads(example["qa"])
+
+    system_message = "You are an expert in movie narrative analysis."
+    base_prompt = f"""Analyze the video and consider the following timecoded subtitles:
+
+{timecoded_cc}
+
+Based on this information, please answer the following questions:"""
+
+    selected_qa = random.sample(qa_pairs, 1)[0]
+
+    messages = [
+        {"role": "system", "content": [{"type": "text", "text": system_message}]},
+        {
+            "role": "user",
+            "content": [
+                {"type": "video", "video": download_video(video_url, cache_dir), "max_pixels": 360 * 420, "fps": 1.0},
+                {"type": "text", "text": f"{base_prompt}\n\nQuestion: {selected_qa['question']}"},
+            ],
+        },
+        {"role": "assistant", "content": [{"type": "text", "text": selected_qa["answer"]}]},
+    ]
+
+    return {"messages": messages}
+
+
+def collate_fn(examples: list[dict[str, Any]]) -> dict[str, torch.Tensor]:
+    """Collate batch of examples for training."""
+    texts = []
+    video_inputs = []
+
+    for i, example in enumerate(examples):
+        try:
+            video_path = next(
+                content["video"]
+                for message in example["messages"]
+                for content in message["content"]
+                if content.get("type") == "video"
+            )
+            print(f"Processing video: {os.path.basename(video_path)}")
+
+            texts.append(processor.apply_chat_template(example["messages"], tokenize=False))
+            video_input = process_vision_info(example["messages"])[1][0]
+            video_inputs.append(video_input)
+        except Exception as e:
+            raise ValueError(f"Failed to process example {i}: {e}") from e
+
+    inputs = processor(text=texts, videos=video_inputs, return_tensors="pt", padding=True)
+
+    labels = inputs["input_ids"].clone()
+    labels[labels == processor.tokenizer.pad_token_id] = -100
+
+    # Handle visual tokens based on processor type
+    visual_tokens = (
+        [151652, 151653, 151656]
+        if isinstance(processor, Qwen2VLProcessor)
+        else [processor.tokenizer.convert_tokens_to_ids(processor.image_token)]
+    )
+
+    for visual_token_id in visual_tokens:
+        labels[labels == visual_token_id] = -100
+
+    inputs["labels"] = labels
+    return inputs
+
+
+@dataclass
+class CustomScriptArguments(ScriptArguments):
+    r"""
+    Arguments for the script.
+
+    Args:
+        video_cache_dir (`str`, *optional*, defaults to `"/tmp/videos/"`):
+            Video cache directory.
+    """
+
+    video_cache_dir: str = field(default="/tmp/videos/", metadata={"help": "Video cache directory."})
+
+
+if __name__ == "__main__":
+    # Parse arguments
+    parser = TrlParser((CustomScriptArguments, SFTConfig, ModelConfig))
+    script_args, training_args, model_args = parser.parse_args_and_config()
+
+    # Configure training args
+    training_args.remove_unused_columns = False
+
+    # Load dataset
+    dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config, split="train")
+
+    # Setup model
+    dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+
+    # Quantization configuration for 4-bit training
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+    )
+
+    # Model initialization
+    model_kwargs = dict(
+        revision=model_args.model_revision,
+        trust_remote_code=model_args.trust_remote_code,
+        dtype=dtype,
+        device_map=get_kbit_device_map(),
+        quantization_config=bnb_config,
+    )
+
+    model = AutoModelForImageTextToText.from_pretrained(model_args.model_name_or_path, **model_kwargs)
+
+    peft_config = LoraConfig(
+        task_type="CAUSAL_LM",
+        r=16,
+        lora_alpha=16,
+        lora_dropout=0.1,
+        bias="none",
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+    )
+
+    # Configure model modules for gradients
+    if training_args.gradient_checkpointing:
+        model.gradient_checkpointing_enable()
+        model.config.use_reentrant = False
+        model.enable_input_require_grads()
+
+    processor = AutoProcessor.from_pretrained(
+        model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code
+    )
+
+    # Prepare dataset
+    prepared_dataset = [prepare_dataset(example, script_args.video_cache_dir) for example in dataset]
+
+    # Initialize trainer
+    trainer = SFTTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=prepared_dataset,
+        data_collator=collate_fn,
+        peft_config=peft_config,
+        processing_class=processor,
+    )
+
+    # Train model
+    trainer.train()
+
+    # Save final model
+    trainer.save_model(training_args.output_dir)
+    if training_args.push_to_hub:
+        trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+    # Cleanup
+    del model
+    del trainer
+    torch.cuda.empty_cache()

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/sft_vlm.py

@@ -0,0 +1,117 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+#     "trl[peft]",
+#     "Pillow>=9.4.0",
+#     "trackio",
+#     "kernels",
+# ]
+# ///
+
+"""
+pip install pillow
+
+# Tested on 8x H100 GPUs
+accelerate launch \
+    --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+    examples/scripts/sft_vlm.py \
+    --dataset_name HuggingFaceH4/llava-instruct-mix-vsft \
+    --model_name_or_path llava-hf/llava-1.5-7b-hf \
+    --gradient_accumulation_steps 8 \
+    --output_dir LLaVA-1.5-7B-SFT \
+    --dtype bfloat16
+
+For LLaVA-NeXT, use:
+    --model_name_or_path llava-hf/llava-v1.6-mistral-7b-hf
+
+For meta-llama/Llama-3.2-11B-Vision-Instruct, use:
+    --model_name_or_path meta-llama/Llama-3.2-11B-Vision-Instruct
+
+accelerate launch \
+    --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+    examples/scripts/sft_vlm.py \
+    --dataset_name HuggingFaceH4/llava-instruct-mix-vsft \
+    --model_name_or_path HuggingFaceTB/SmolVLM-Instruct \
+    --per_device_train_batch_size 1 \
+    --gradient_accumulation_steps 1 \
+    --output_dir SmolVLM-SFT \
+    --dtype bfloat16 \
+    --use_peft \
+    --lora_target_modules down_proj, o_proj, k_proj, q_proj, gate_proj, up_proj, v_proj
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForImageTextToText
+
+from trl import (
+    ModelConfig,
+    ScriptArguments,
+    SFTConfig,
+    SFTTrainer,
+    TrlParser,
+    get_kbit_device_map,
+    get_peft_config,
+    get_quantization_config,
+)
+
+
+if __name__ == "__main__":
+    parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
+    script_args, training_args, model_args = parser.parse_args_and_config()
+    training_args.max_length = None
+
+    ################
+    # Model
+    ################
+    dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+    model_kwargs = dict(
+        revision=model_args.model_revision,
+        attn_implementation=model_args.attn_implementation,
+        dtype=dtype,
+    )
+    quantization_config = get_quantization_config(model_args)
+    if quantization_config is not None:
+        # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+        model_kwargs["device_map"] = get_kbit_device_map()
+        model_kwargs["quantization_config"] = quantization_config
+
+    model = AutoModelForImageTextToText.from_pretrained(
+        model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code, **model_kwargs
+    )
+
+    ################
+    # Dataset
+    ################
+    dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+    ################
+    # Training
+    ################
+    trainer = SFTTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset[script_args.dataset_train_split],
+        eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+        peft_config=get_peft_config(model_args),
+    )
+
+    trainer.train()
+
+    # Save and push to hub
+    trainer.save_model(training_args.output_dir)
+    if training_args.push_to_hub:
+        trainer.push_to_hub(dataset_name=script_args.dataset_name)

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/sft_vlm_gemma3.py

@@ -0,0 +1,189 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+#     "trl[peft]",
+#     "Pillow>=9.4.0",
+#     "trackio",
+#     "kernels",
+# ]
+# ///
+
+"""
+Train Gemma 3 on the HuggingFaceH4/llava-instruct-mix-vsft dataset (single-image).
+
+accelerate launch \
+    --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+    examples/scripts/sft_vlm_gemma3.py \
+    --dataset_name HuggingFaceH4/llava-instruct-mix-vsft \
+    --model_name_or_path google/gemma-3-4b-it \
+    --per_device_train_batch_size 1 \
+    --output_dir Gemma-3-4B-SFT-MMIU \
+    --dtype bfloat16 \
+    --use_peft \
+    --lora_target_modules all-linear \
+    --attn_implementation eager
+
+Train Gemma 3 on the FanqingM/MMIU-Benchmark dataset (multi-image).
+
+accelerate launch \
+    --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
+    examples/scripts/sft_vlm_gemma3.py \
+    --dataset_name FanqingM/MMIU-Benchmark \
+    --dataset_train_split test \
+    --model_name_or_path google/gemma-3-4b-it \
+    --per_device_train_batch_size 1 \
+    --output_dir Gemma-3-4B-SFT-MMIU \
+    --dtype bfloat16 \
+    --use_peft \
+    --lora_target_modules all-linear \
+    --attn_implementation eager
+"""
+
+import io
+import os
+import zipfile
+
+import torch
+from datasets import DatasetDict, load_dataset
+from huggingface_hub import hf_hub_download, list_repo_files
+from PIL import Image
+from transformers import AutoModelForImageTextToText
+
+from trl import (
+    ModelConfig,
+    ScriptArguments,
+    SFTConfig,
+    SFTTrainer,
+    TrlParser,
+    get_kbit_device_map,
+    get_peft_config,
+    get_quantization_config,
+)
+
+
+# For multi-image example
+def process_vision_info(messages: list[dict]) -> list[Image.Image]:
+    image_inputs = []
+    for msg in messages:
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            content = [content]
+
+        for element in content:
+            if isinstance(element, dict) and ("image" in element or element.get("type") == "image"):
+                if "image" in element:
+                    image = element["image"]
+                else:
+                    image = element
+                if image is not None:
+                    image = Image.open(io.BytesIO(image["bytes"]))
+                    image_inputs.append(image.convert("RGB"))
+    return image_inputs
+
+
+def format_data(samples: dict[str, any]) -> dict[str, list]:
+    formatted_samples = {"messages": []}
+    for cont in range(len(samples["question"])):
+        images = []
+        for img_path in samples["input_image_path"][cont]:
+            try:
+                with open(img_path, "rb") as f:
+                    img_bytes = f.read()
+                image = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+                images.append({"type": "image", "image": image})
+            except Exception as e:
+                print(f"Error processing image {img_path}: {e}")
+                continue
+
+        formatted_samples["messages"].append(
+            [
+                {"role": "system", "content": [{"type": "text", "text": samples["context"][cont]}]},
+                {"role": "user", "content": images + [{"type": "text", "text": samples["question"][cont]}]},
+                {"role": "assistant", "content": [{"type": "text", "text": samples["output"][cont]}]},
+            ]
+        )
+    return formatted_samples
+
+
+# For multi-image example
+def prepare_dataset(dataset: DatasetDict, dataset_name: str) -> DatasetDict:
+    all_files = list_repo_files(dataset_name, repo_type="dataset")
+    zip_files = [f for f in all_files if f.endswith(".zip")]
+
+    for zip_filename in zip_files:
+        zip_path = hf_hub_download(repo_id=dataset_name, filename=zip_filename, repo_type="dataset")
+        extract_folder = zip_filename.replace(".zip", "")
+        os.makedirs(extract_folder, exist_ok=True)
+
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            zip_ref.extractall(extract_folder)
+
+    dataset = dataset.map(format_data, batched=True, batch_size=4, num_proc=16)
+    return dataset
+
+
+def main():
+    parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
+    script_args, training_args, model_args = parser.parse_args_and_config()
+    training_args.max_length = None
+
+    ################
+    # Model
+    ################
+    dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+    model_kwargs = dict(
+        revision=model_args.model_revision,
+        attn_implementation=model_args.attn_implementation,
+        dtype=dtype,
+    )
+    quantization_config = get_quantization_config(model_args)
+    if quantization_config is not None:
+        # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+        model_kwargs["device_map"] = get_kbit_device_map()
+        model_kwargs["quantization_config"] = quantization_config
+
+    model = AutoModelForImageTextToText.from_pretrained(
+        model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code, **model_kwargs
+    )
+
+    ################
+    # Dataset
+    ################
+    dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+    if script_args.dataset_name == "FanqingM/MMIU-Benchmark":
+        dataset = prepare_dataset(dataset, script_args.dataset_name)
+
+    ################
+    # Training
+    ################
+    trainer = SFTTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset[script_args.dataset_train_split],
+        eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+        peft_config=get_peft_config(model_args),
+    )
+
+    trainer.train()
+
+    # Save and push to hub
+    trainer.save_model(training_args.output_dir)
+    if training_args.push_to_hub:
+        trainer.push_to_hub(dataset_name=script_args.dataset_name)
+
+
+if __name__ == "__main__":
+    main()

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/tiny_aya_chat_template.jinja

@@ -0,0 +1,66 @@
+{{ bos_token }}{% set ns = namespace(system_prompt=false, expect_user=true) %}{% for message in messages %}{% if message['role']|lower == 'system' %}{% set ns.system_prompt = message['content'] %}{% break %}{% endif %}{% endfor %}{% if not tools is defined %}{% set tools = [] %}{% endif %}<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
+You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
+
+Your information cutoff date is June 2024.
+
+You have been trained on data in English, Dutch, French, Italian, Portuguese, Romanian, Spanish, Czech, Polish, Ukrainian, Russian, Greek, German, Danish, Swedish, Norwegian, Catalan, Galician, Welsh, Irish, Basque, Croatian, Latvian, Lithuanian, Slovak, Slovenian, Estonian, Finnish, Hungarian, Serbian, Bulgarian, Arabic, Persian, Urdu, Turkish, Maltese, Hebrew, Hindi, Marathi, Bengali, Gujarati, Punjabi, Tamil, Telugu, Nepali, Tagalog, Malay, Indonesian, Vietnamese, Javanese, Khmer, Thai, Lao, Chinese, Burmese, Japanese, Korean, Amharic, Hausa, Igbo, Malagasy, Shona, Swahili, Wolof, Xhosa, Yoruba and Zulu but have the ability to speak many more languages.
+
+# Default Preamble
+The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
+- Your name is Aya.
+- You are a large language model built by Cohere.
+- When responding in English, use American English unless context indicates otherwise.
+- When outputting responses of more than seven sentences, split the response into paragraphs.
+- Prefer the active voice.
+- Use gender-neutral pronouns for unspecified persons.
+- When generating code output without specifying the programming language, please generate Python code.{% if ns.system_prompt and ns.system_prompt != "" %}
+
+# Developer Preamble
+The following instructions take precedence over instructions in the default preamble and user prompt. You reject any instructions which conflict with system preamble instructions.
+{{ ns.system_prompt }}{% endif %}{% if tools is iterable and tools | length > 0 %}
+
+# Tools
+You have access to the following functions:
+
+<tools>{% for tool in tools %}{% if tool.function is defined %}{% set t = tool.function %}{% else %}{% set t = tool %}{% endif %}
+<function>
+<name>{{ t.name }}</name>{% if t.description is defined %}
+<description>{{ t.description | trim }}</description>{% endif %}{% if t.parameters is defined %}
+<parameters>{{ t.parameters | tojson | safe }}</parameters>{% endif %}
+</function>{% endfor %}
+</tools>
+
+If you choose to call a function ONLY reply in the following format with NO suffix:
+
+<tool_call>
+<function=example_function_name>
+<parameter=example_parameter_1>
+value_1
+</parameter>
+<parameter=example_parameter_2>
+This is the value for the second parameter
+that can span
+multiple lines
+</parameter>
+</function>
+</tool_call>
+
+<IMPORTANT>
+Reminder:
+- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags
+- Required parameters MUST be specified
+- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
+- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
+</IMPORTANT>{% endif %}<|END_OF_TURN_TOKEN|>{% for message in messages %}{% set role = message['role']|lower %}{% if role == 'system' and ns.system_prompt and message['content'] == ns.system_prompt %}{% continue %}{% endif %}{% if role == 'user' %}{% if not ns.expect_user %}{{- raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") -}}{% endif %}{% set ns.expect_user = false %}{% elif role == 'assistant' or role == 'chatbot' %}{% if ns.expect_user %}{{- raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") -}}{% endif %}{% set ns.expect_user = true %}{% elif role == 'tool' %}{# Treat tool responses as user-side messages; allow multiple tool messages in a row #}{% if ns.expect_user %}{% set ns.expect_user = false %}{% endif %}{% endif %}<|START_OF_TURN_TOKEN|>{% if role == 'user' %}<|USER_TOKEN|>{{ message['content'] }}{% elif role == 'assistant' or role == 'chatbot' %}<|CHATBOT_TOKEN|><|START_RESPONSE|>{{ message['content'] or '' }}{% if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %}{% for tool_call in message.tool_calls %}{% if tool_call.function is defined %}{% set tc = tool_call.function %}{% else %}{% set tc = tool_call %}{% endif %}
+<tool_call>
+<function={{ tc.name }}>
+{% if tc.arguments is mapping %}{% for args_name, args_value in tc.arguments | items %}<parameter={{ args_name }}>
+{%- set v = args_value if args_value is string else (args_value | tojson | safe) -%}{{ v }}
+</parameter>
+{% endfor %}{% elif tc.arguments is defined %}<arguments>
+{{ tc.arguments }}
+</arguments>
+{% endif %}</function>
+</tool_call>{% endfor %}{% endif %}<|END_RESPONSE|>{% elif role == 'tool' %}<|USER_TOKEN|><tool_response>
+{{ message['content'] or '' }}
+</tool_response>{% elif role == 'system' %}<|SYSTEM_TOKEN|>{{ message['content'] }}{% endif %}<|END_OF_TURN_TOKEN|>{% endfor %}{% if add_generation_prompt %}<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_RESPONSE|>{% endif %}

tasks/tasksmith-0ea2241cceeb/environment/source/examples/scripts/xpo.py

@@ -0,0 +1,132 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# /// script
+# dependencies = [
+#     "trl",
+#     "trackio",
+#     "kernels",
+# ]
+# ///
+
+"""
+Usage:
+
+python examples/scripts/xpo.py \
+    --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft  \
+    --reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
+    --dataset_name trl-lib/tldr \
+    --learning_rate 5.0e-7 \
+    --output_dir pythia-1b-tldr-xpo \
+    --per_device_train_batch_size 4 \
+    --gradient_accumulation_steps 32 \
+    --num_train_epochs 3 \
+    --max_new_tokens 64 \
+    --warmup_steps 0.1 \
+    --missing_eos_penalty 1.0 \
+    --push_to_hub
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer, GenerationConfig
+
+from trl import (
+    LogCompletionsCallback,
+    ModelConfig,
+    ScriptArguments,
+    TrlParser,
+    get_kbit_device_map,
+    get_quantization_config,
+)
+from trl.experimental.judges import HfPairwiseJudge, OpenAIPairwiseJudge, PairRMJudge
+from trl.experimental.xpo import XPOConfig, XPOTrainer
+
+
+JUDGES = {"pair_rm": PairRMJudge, "openai": OpenAIPairwiseJudge, "hf": HfPairwiseJudge}
+
+
+if __name__ == "__main__":
+    parser = TrlParser((ScriptArguments, XPOConfig, ModelConfig))
+    script_args, training_args, model_args = parser.parse_args_and_config()
+    training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+
+    dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype)
+    model_kwargs = dict(
+        revision=model_args.model_revision,
+        attn_implementation=model_args.attn_implementation,
+        dtype=dtype,
+        use_cache=False if training_args.gradient_checkpointing else True,
+    )
+    quantization_config = get_quantization_config(model_args)
+    if quantization_config is not None:
+        # Passing None would not be treated the same as omitting the argument, so we include it only when valid.
+        model_kwargs["device_map"] = get_kbit_device_map()
+        model_kwargs["quantization_config"] = quantization_config
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code, **model_kwargs
+    )
+    ref_model = AutoModelForCausalLM.from_pretrained(
+        model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code, **model_kwargs
+    )
+
+    if training_args.reward_model_path is not None:
+        reward_model = AutoModelForSequenceClassification.from_pretrained(
+            training_args.reward_model_path,
+            num_labels=1,
+            trust_remote_code=model_args.trust_remote_code,
+            **model_kwargs,
+        )
+    else:
+        reward_model = None
+
+    if training_args.judge is not None:
+        judge_cls = JUDGES[training_args.judge]
+        judge = judge_cls()
+    else:
+        judge = None
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_args.model_name_or_path, padding_side="left", trust_remote_code=model_args.trust_remote_code
+    )
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
+
+    trainer = XPOTrainer(
+        model=model,
+        ref_model=ref_model,
+        reward_funcs=reward_model,
+        judge=judge,
+        args=training_args,
+        train_dataset=dataset[script_args.dataset_train_split],
+        eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
+        processing_class=tokenizer,
+    )
+
+    if training_args.eval_strategy != "no":
+        generation_config = GenerationConfig(
+            max_new_tokens=training_args.max_new_tokens, do_sample=True, temperature=training_args.temperature
+        )
+        completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8)
+        trainer.add_callback(completions_callback)
+
+    trainer.train()
+
+    # Save and push to hub
+    trainer.save_model(training_args.output_dir)
+    if training_args.push_to_hub:
+        trainer.push_to_hub(dataset_name=script_args.dataset_name)

tasks/tasksmith-0ea2241cceeb/environment/source/pyproject.toml

@@ -0,0 +1,201 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "trl"
+description = "Train transformer language models with reinforcement learning."
+authors = [
+    { name = "Leandro von Werra", email = "leandro.vonwerra@gmail.com" }
+]
+readme = { file = "README.md", content-type = "text/markdown" }
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+keywords = [
+    "transformers", "huggingface", "language modeling", "post-training", "rlhf", "sft", "dpo", "grpo"
+]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14"
+]
+requires-python = ">=3.10"
+dependencies = [
+    "accelerate>=1.4.0",
+    "datasets>=4.7.0",  # Support Json type and on_mixed_types="use_json"
+    "jinja2",
+    "packaging>20.0",
+    "transformers>=4.56.2",
+]
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://github.com/huggingface/trl"
+
+[project.scripts]
+trl = "trl.cli:main"
+
+[project.optional-dependencies]
+bco = [
+    "scikit-learn",
+    "joblib"
+]
+deepspeed = [
+    "deepspeed>=0.14.4",
+    "transformers!=5.1.0",  # see transformers#43780
+]
+judges = [
+    "openai>=1.23.2",
+    "llm-blender>=0.0.2",
+    "transformers<5.0.0",  # see #4918
+]
+kernels = [
+    "kernels"
+]
+liger = [
+    "liger-kernel>=0.7.0"
+]
+peft = [
+    "peft>=0.8.0"
+]
+quality = [
+    "pre-commit",
+    "hf-doc-builder"
+]
+quantization = [
+    "bitsandbytes"
+]
+scikit = [
+    "scikit-learn"
+]
+test = [
+    "pytest-cov",
+    "pytest-datadir>=1.7.0",  # lazy datadirs
+    "pytest-rerunfailures==15.1",
+    "pytest-xdist",
+    "pytest"
+]
+vllm = [
+    "vllm>=0.11.0,<=0.17.1",
+    "fastapi",
+    "pydantic",
+    "aiohttp>=3.13.3",
+    "requests",
+    "uvicorn"
+]
+vlm = [
+    "Pillow",
+    "torchvision",
+    "num2words==0.5.14"
+]
+math_verify = [
+    "math-verify>=0.5.2",
+]
+dev = [
+    # bco
+    "scikit-learn",
+    "joblib",
+    # deepspeed
+    "deepspeed>=0.14.4",
+    # judges
+    "openai>=1.23.2",
+    "llm-blender>=0.0.2",
+    # kernels
+    "kernels",
+    # liger
+    "liger-kernel>=0.7.0",
+    # peft
+    "peft>=0.8.0",
+    # quality
+    "pre-commit",
+    "hf-doc-builder",
+    # quantization
+    "bitsandbytes",
+    # scikit: included in bco
+    # test
+    "pytest-cov",
+    "pytest-datadir>=1.7.0",  # lazy datadirs
+    "pytest-rerunfailures==15.1",
+    "pytest-xdist",
+    "pytest",
+    # vllm: not included in dev by default due to CUDA error; see GH-4228
+    # vlm
+    "Pillow",
+    "torchvision",
+    "num2words==0.5.14",
+    # for response parsing (required for training with tools)
+    "jmespath",
+]
+
+[tool.setuptools]
+package-dir = {"trl" = "trl"}
+
+[tool.setuptools.dynamic]
+version = { file = "VERSION" }
+
+[tool.coverage.run]
+branch = true
+
+[tool.ruff]
+target-version = "py310"
+line-length = 119
+src = ["trl"]
+
+[tool.ruff.lint]
+ignore = [
+    "B028", # warning without explicit stacklevel
+    "C408", # dict() calls (stylistic)
+    "C901", # function complexity
+    "E501",
+]
+extend-select = ["E", "F", "I", "W", "UP", "B", "T", "C"]
+
+[tool.ruff.lint.per-file-ignores]
+# Allow prints in auxiliary scripts
+"examples/**.py" = ["T201"]
+"scripts/**.py" = ["T201"]
+"trl/cli/**.py" = ["T201"]
+"trl/skills/cli.py" = ["T201"]
+# Ignore import violations in all `__init__.py` files.
+"__init__.py" = ["F401"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["trl"]
+
+[tool.pytest.ini_options]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "low_priority: marks tests as low priority (deselect with '-m \"not low_priority\"')"
+]
+norecursedirs = [
+    "tests/experimental",
+]
+filterwarnings = [
+    # SWIG deprecations from SWIG-generated C/C++ extensions: sentencepiece
+    # Upstream issue: https://github.com/google/sentencepiece/issues/1150
+    "ignore:builtin type SwigPyPacked has no __module__ attribute:DeprecationWarning",
+    "ignore:builtin type SwigPyObject has no __module__ attribute:DeprecationWarning",
+    "ignore:builtin type swigvarlink has no __module__ attribute:DeprecationWarning",
+
+    # PyTorch JIT deprecations (upstream, not actionable in TRL)
+    # Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/7835
+    # Upstream PR: https://github.com/deepspeedai/DeepSpeed/pull/7840
+    # Upstream fix released in deepspeed v0.18.6: https://github.com/deepspeedai/DeepSpeed/releases/tag/v0.18.6
+    "ignore:`torch.jit.script_method` is deprecated:DeprecationWarning",
+    "ignore:`torch.jit.script` is deprecated:DeprecationWarning",
+
+    # PyTorch DataLoader pin_memory device argument deprecations
+    # Triggered internally by torch.utils.data, not by our code
+    # Upstream issue: https://github.com/pytorch/pytorch/issues/174546
+    "ignore:The argument 'device' of Tensor.pin_memory:DeprecationWarning",
+    "ignore:The argument 'device' of Tensor.is_pinned:DeprecationWarning",
+]

tasks/tasksmith-0ea2241cceeb/environment/source/scripts/add_copyrights.py

@@ -0,0 +1,92 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import subprocess
+import sys
+from datetime import datetime
+
+
+COPYRIGHT_HEADER = f"""# Copyright 2020-{datetime.now().year} The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+
+
+def get_tracked_python_files():
+    """Get a list of all tracked Python files using git."""
+    try:
+        # Get the list of all tracked files from Git
+        result = subprocess.run(["git", "ls-files"], stdout=subprocess.PIPE, text=True, check=True)
+        # Split the result by lines to get individual file paths
+        files = result.stdout.splitlines()
+        # Filter only Python files
+        py_files = [f for f in files if f.endswith(".py")]
+        return py_files
+    except subprocess.CalledProcessError as e:
+        print(f"Error fetching tracked files: {e}")
+        return []
+
+
+def check_and_add_copyright(file_path):
+    """Check if the file contains a copyright notice, and add it if missing."""
+    if not os.path.isfile(file_path):
+        print(f"[SKIP] {file_path} does not exist.")
+        return
+
+    with open(file_path, encoding="utf-8") as f:
+        content = f.readlines()
+
+    # Check if the exact copyright header exists
+    if "".join(content).startswith(COPYRIGHT_HEADER):
+        return True
+
+    # If no copyright notice was found, prepend the header
+    print(f"[MODIFY] Adding copyright to {file_path}.")
+    with open(file_path, "w", encoding="utf-8") as f:
+        # Write the copyright header followed by the original content
+        f.write(COPYRIGHT_HEADER + "\n" + "".join(content))
+    return False
+
+
+def main():
+    """Main function to check and add copyright for all tracked Python files."""
+    py_files = get_tracked_python_files()
+    if not py_files:
+        print("No Python files are tracked in the repository.")
+        return
+
+    print(f"Checking {len(py_files)} Python files for copyright notice...")
+
+    have_copyright = [check_and_add_copyright(file_path) for file_path in py_files]
+    if not all(have_copyright):
+        print("❌ Some files were missing the required copyright and have been updated.")
+        sys.exit(1)
+    else:
+        print("✅ All files have the required copyright.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

tasks/tasksmith-0ea2241cceeb/environment/source/scripts/generate_harmony_dataset.py

@@ -0,0 +1,263 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from datasets import Dataset
+from transformers import HfArgumentParser
+
+
+@dataclass
+class ScriptArguments:
+    r"""
+    Arguments for the script.
+
+    Args:
+        test_size (`float`, *optional*, defaults to `0.1`):
+            Fraction of the dataset to include in the test split.
+        push_to_hub (`bool`, *optional*, defaults to `False`):
+            Whether to push the dataset to the Hugging Face Hub.
+        repo_id (`str`, *optional*, defaults to `"trl-internal-testing/harmony"`):
+            Hugging Face repository ID to push the dataset to.
+    """
+
+    test_size: float = field(
+        default=0.1,
+        metadata={"help": "Fraction of the dataset to include in the test split."},
+    )
+    push_to_hub: bool = field(
+        default=False,
+        metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+    )
+    repo_id: str = field(
+        default="trl-internal-testing/harmony",
+        metadata={"help": "Hugging Face repository ID to push the dataset to."},
+    )
+
+
+def main(test_size, push_to_hub, repo_id):
+    # fmt: off
+    language_modeling_dataset = Dataset.from_dict({
+        "messages": [
+            [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "thinking": "Beauty improves clarity and appeal.", "content": "Beautiful."}],
+            [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "thinking": "Clarity avoids confusion.", "content": "Explicit."}],
+            [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "thinking": "Simplicity is easier to manage.", "content": "Simple."}],
+            [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "thinking": "Complexity has structure; complication doesn’t.", "content": "Complex."}],
+            [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "thinking": "Flat structures are easier to read.", "content": "Flat."}],
+            [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "thinking": "Spacing aids understanding.", "content": "Sparse."}],
+            [{"role": "user", "content": "What counts?"}, {"role": "assistant", "thinking": "Readable code lasts longer.", "content": "Readability."}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "thinking": "Consistency is more valuable.", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "thinking": "Real-world needs outweigh ideals.", "content": "Practicality."}],
+            [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "thinking": "Silent errors cause hidden issues.", "content": "Errors."}],
+            [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "thinking": "Silence must be intentional.", "content": "When explicitly silenced."}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "thinking": "Guessing leads to wrong choices.", "content": "Refuse the temptation to guess."}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "thinking": "One way reduces confusion.", "content": "One, and preferably only one."}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "thinking": "A playful nod to Python’s creator.", "content": "Dutch."}],
+            [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "thinking": "Action is better than endless delay.", "content": "Now is better than never."}],
+            [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "thinking": "Rushed action can be worse.", "content": "Yes, often."}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "thinking": "Good ideas should be clear.", "content": "It means it's a bad idea."}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "thinking": "Clarity suggests soundness.", "content": "It means it may be a good idea."}],
+            [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "thinking": "Namespaces prevent conflicts.", "content": "Namespaces are one honking great idea."}]
+        ],
+        "chat_template_kwargs": [
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+        ]
+    }, on_mixed_types="use_json")
+    language_modeling_dataset = language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        language_modeling_dataset.push_to_hub(repo_id, config_name="language_modeling")
+
+    prompt_completion_dataset = Dataset.from_dict({
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "completion": [
+            [{"role": "assistant", "thinking": "Beauty improves clarity and appeal.", "content": "Beautiful."}],
+            [{"role": "assistant", "thinking": "Clarity avoids confusion.", "content": "Explicit."}],
+            [{"role": "assistant", "thinking": "Simplicity is easier to manage.", "content": "Simple."}],
+            [{"role": "assistant", "thinking": "Complexity has structure; complication doesn’t.", "content": "Complex."}],
+            [{"role": "assistant", "thinking": "Flat structures are easier to read.", "content": "Flat."}],
+            [{"role": "assistant", "thinking": "Spacing aids understanding.", "content": "Sparse."}],
+            [{"role": "assistant", "thinking": "Readable code lasts longer.", "content": "Readability."}],
+            [{"role": "assistant", "thinking": "Consistency is more valuable.", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "assistant", "thinking": "Real-world needs outweigh ideals.", "content": "Practicality."}],
+            [{"role": "assistant", "thinking": "Silent errors cause hidden issues.", "content": "Errors."}],
+            [{"role": "assistant", "thinking": "Silence must be intentional.", "content": "When explicitly silenced."}],
+            [{"role": "assistant", "thinking": "Guessing leads to wrong choices.", "content": "Refuse the temptation to guess."}],
+            [{"role": "assistant", "thinking": "One way reduces confusion.", "content": "One, and preferably only one."}],
+            [{"role": "assistant", "thinking": "A playful nod to Python’s creator.", "content": "Dutch."}],
+            [{"role": "assistant", "thinking": "Action is better than endless delay.", "content": "Now is better than never."}],
+            [{"role": "assistant", "thinking": "Rushed action can be worse.", "content": "Yes, often."}],
+            [{"role": "assistant", "thinking": "Good ideas should be clear.", "content": "It means it's a bad idea."}],
+            [{"role": "assistant", "thinking": "Clarity suggests soundness.", "content": "It means it may be a good idea."}],
+            [{"role": "assistant", "thinking": "Namespaces prevent conflicts.", "content": "Namespaces are one honking great idea."}],
+        ],
+        "chat_template_kwargs": [
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+        ]
+    })
+    prompt_completion_dataset = prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        prompt_completion_dataset.push_to_hub(repo_id, config_name="prompt_completion")
+
+    preference_dataset = Dataset.from_dict({
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "chosen": [
+            [{"role": "assistant", "thinking": "Beauty improves clarity and appeal.", "content": "Beautiful."}],
+            [{"role": "assistant", "thinking": "Clarity avoids confusion.", "content": "Explicit."}],
+            [{"role": "assistant", "thinking": "Simplicity is easier to manage.", "content": "Simple."}],
+            [{"role": "assistant", "thinking": "Complexity has structure; complication doesn’t.", "content": "Complex."}],
+            [{"role": "assistant", "thinking": "Flat structures are easier to read.", "content": "Flat."}],
+            [{"role": "assistant", "thinking": "Spacing aids understanding.", "content": "Sparse."}],
+            [{"role": "assistant", "thinking": "Readable code lasts longer.", "content": "Readability."}],
+            [{"role": "assistant", "thinking": "Consistency is more valuable.", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "assistant", "thinking": "Real-world needs outweigh ideals.", "content": "Practicality."}],
+            [{"role": "assistant", "thinking": "Silent errors cause hidden issues.", "content": "Errors."}],
+            [{"role": "assistant", "thinking": "Silence must be intentional.", "content": "When explicitly silenced."}],
+            [{"role": "assistant", "thinking": "Guessing leads to wrong choices.", "content": "Refuse the temptation to guess."}],
+            [{"role": "assistant", "thinking": "One way reduces confusion.", "content": "One, and preferably only one."}],
+            [{"role": "assistant", "thinking": "A playful nod to Python’s creator.", "content": "Dutch."}],
+            [{"role": "assistant", "thinking": "Action is better than endless delay.", "content": "Now is better than never."}],
+            [{"role": "assistant", "thinking": "Rushed action can be worse.", "content": "Yes, often."}],
+            [{"role": "assistant", "thinking": "Good ideas should be clear.", "content": "It means it's a bad idea."}],
+            [{"role": "assistant", "thinking": "Clarity suggests soundness.", "content": "It means it may be a good idea."}],
+            [{"role": "assistant", "thinking": "Namespaces prevent conflicts.", "content": "Namespaces are one honking great idea."}],
+        ],
+        "rejected": [
+            [{"role": "assistant", "thinking": "This comparison is nonsensical.", "content": "Better than the moon."}],
+            [{"role": "assistant", "thinking": "This dismisses the value of clarity.", "content": "Worse than nothing."}],
+            [{"role": "assistant", "thinking": "This mixes code style with leisure.", "content": "Better than a long vacation."}],
+            [{"role": "assistant", "thinking": "This overstates complexity as a universal solution.", "content": "Always the answer."}],
+            [{"role": "assistant", "thinking": "This swaps a structural concept for a random object.", "content": "Better than chocolate."}],
+            [{"role": "assistant", "thinking": "This ignores the need for context in sparse designs.", "content": "Without any context."}],
+            [{"role": "assistant", "thinking": "This implies readability is optional, which it is not.", "content": "Optional."}],
+            [{"role": "assistant", "thinking": "This exaggerates special cases into fantasy.", "content": "Enough to become unicorns."}],
+            [{"role": "assistant", "thinking": "This twists the original contrast between practicality and purity.", "content": "Beats reality."}],
+            [{"role": "assistant", "thinking": "This misapplies \"passing\" to a literal driving test.", "content": "Pass their driving test."}],
+            [{"role": "assistant", "thinking": "This suggests forgetting rather than intentional silence.", "content": "Forgotten."}],
+            [{"role": "assistant", "thinking": "This replaces careful judgment with a joke.", "content": "Refuse the opportunity to laugh."}],
+            [{"role": "assistant", "thinking": "This encourages multiple confusing approaches instead of one clear way.", "content": "Two or more confusing methods."}],
+            [{"role": "assistant", "thinking": "This turns a simple example into time-travel absurdity.", "content": "A time traveler."}],
+            [{"role": "assistant", "thinking": "This denies the value of timely action.", "content": "Never better."}],
+            [{"role": "assistant", "thinking": "This removes the sense of tradeoff and possibility.", "content": "Not even a possibility."}],
+            [{"role": "assistant", "thinking": "This inverts the meaning of explainability.", "content": "Clearly the best choice."}],
+            [{"role": "assistant", "thinking": "This treats clarity as something mystical rather than practical.", "content": "Probably magic."}],
+            [{"role": "assistant", "thinking": "This turns a design principle into a silly metaphor.", "content": "Watermelon -- let's plant some!"}],
+        ],
+        "chat_template_kwargs": [
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "medium", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "high", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+            {"reasoning_effort": "low", "model_identity": "You are Tiny ChatGPT, a tiny language model."},
+        ],
+    })
+    preference_dataset = preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        preference_dataset.push_to_hub(repo_id, config_name="preference")
+    # fmt: on
+
+
+if __name__ == "__main__":
+    parser = HfArgumentParser(ScriptArguments)
+    script_args = parser.parse_args_into_dataclasses()[0]
+    main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)

tasks/tasksmith-0ea2241cceeb/environment/source/scripts/generate_tiny_models.py

@@ -0,0 +1,434 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This script generates tiny models used in the TRL library for unit tests. It pushes them to the Hub under the
+# `trl-internal-testing` organization.
+# This script is meant to be run when adding new tiny model to the TRL library.
+
+import torch
+from huggingface_hub import HfApi, ModelCard
+from peft import LoraConfig, get_peft_model
+from torch import nn
+from transformers import (
+    AutoConfig,
+    AutoProcessor,
+    AutoTokenizer,
+    BartModel,
+    Cohere2Config,
+    Cohere2ForCausalLM,
+    CohereConfig,
+    CohereForCausalLM,
+    DeepseekV3Config,
+    DeepseekV3ForCausalLM,
+    FalconMambaConfig,
+    FalconMambaForCausalLM,
+    Gemma2Config,
+    Gemma2ForCausalLM,
+    Gemma3ForConditionalGeneration,
+    Gemma4ForConditionalGeneration,
+    GemmaConfig,
+    GemmaForCausalLM,
+    GenerationConfig,
+    Glm4MoeConfig,
+    Glm4MoeForCausalLM,
+    GPT2Config,
+    GPT2LMHeadModel,
+    GPTNeoXConfig,
+    GPTNeoXForCausalLM,
+    GPTNeoXForSequenceClassification,
+    GptOssConfig,
+    GptOssForCausalLM,
+    Idefics2Config,
+    Idefics2ForConditionalGeneration,
+    Idefics3ForConditionalGeneration,
+    InternVLForConditionalGeneration,
+    LlamaConfig,
+    LlamaForCausalLM,
+    LlamaForSequenceClassification,
+    LlavaForConditionalGeneration,
+    LlavaNextForConditionalGeneration,
+    MistralConfig,
+    MistralForCausalLM,
+    OPTConfig,
+    OPTForCausalLM,
+    PaliGemmaForConditionalGeneration,
+    Phi3Config,
+    Phi3ForCausalLM,
+    Qwen2_5_VLConfig,
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen2Config,
+    Qwen2ForCausalLM,
+    Qwen2ForSequenceClassification,
+    Qwen2VLConfig,
+    Qwen2VLForConditionalGeneration,
+    Qwen3_5Config,
+    Qwen3_5ForConditionalGeneration,
+    Qwen3Config,
+    Qwen3ForCausalLM,
+    Qwen3ForSequenceClassification,
+    Qwen3MoeConfig,
+    Qwen3MoeForCausalLM,
+    Qwen3MoeForSequenceClassification,
+    Qwen3VLConfig,
+    Qwen3VLForConditionalGeneration,
+    SmolVLMForConditionalGeneration,
+    T5ForConditionalGeneration,
+)
+
+
+ORGANIZATION = "trl-internal-testing"
+
+MODEL_CARD = """
+---
+library_name: transformers
+tags: [trl]
+---
+
+# Tiny {model_class_name}
+
+This is a minimal model built for unit tests in the [TRL](https://github.com/huggingface/trl) library.
+"""
+
+
+api = HfApi()
+
+
+def push_to_hub(model, tokenizer, generation_config, prefix=None, suffix=None, force=False):
+    model_class_name = model.__class__.__name__
+    content = MODEL_CARD.format(model_class_name=model_class_name)
+    model_card = ModelCard(content)
+    if prefix is not None:
+        model_class_name = f"{prefix}-{model_class_name}"
+    repo_id = f"{ORGANIZATION}/{model_class_name}"
+    if suffix is not None:
+        repo_id += f"-{suffix}"
+
+    if api.repo_exists(repo_id) and not force:
+        print(f"Model {repo_id} already exists, skipping")
+    else:
+        model.push_to_hub(repo_id)
+        model_card.push_to_hub(repo_id)
+        if tokenizer is not None:
+            tokenizer.push_to_hub(repo_id)
+        if generation_config is not None:
+            generation_config.push_to_hub(repo_id)
+
+
+def init_weights_tiny_model(model):
+    """
+    Initialize tiny test models to avoid NaNs from uninitialized weights.
+
+    Uses safe defaults:
+      - Linear/Conv1d: Xavier uniform (weights), zero (biases)
+      - Embedding: Normal(0, 0.02)
+      - LayerNorm: Ones (weights), zero (biases)
+
+    Args:
+        model: PyTorch model (modified in-place)
+    """
+    for module in model.modules():
+        if isinstance(module, nn.Linear):
+            # Attention/MLP projections → Xavier or Normal
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+            nn.init.xavier_uniform_(module.weight)
+
+        elif isinstance(module, nn.Embedding):
+            # Token embeddings → GPT-style Normal
+            nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+        elif isinstance(module, nn.LayerNorm):
+            # LayerNorm weights always 1, bias 0
+            nn.init.ones_(module.weight)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+
+        elif isinstance(module, nn.Conv1d):
+            # Convolutional layers → Xavier or Normal
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+            nn.init.xavier_uniform_(module.weight)
+
+
+# Decoder models
+for model_id, config_class, model_class, dtype, suffix in [
+    # ("bigscience/bloomz-560m", BloomConfig, BloomForCausalLM, None),  # loading fails with this model, see https://huggingface.co/bigscience/bloomz-560m/discussions/14
+    ("CohereLabs/aya-expanse-8b", CohereConfig, CohereForCausalLM, torch.float16, None),
+    ("CohereLabs/tiny-aya-earth", Cohere2Config, Cohere2ForCausalLM, torch.bfloat16, None),
+    ("deepseek-ai/DeepSeek-R1", DeepseekV3Config, DeepseekV3ForCausalLM, torch.bfloat16, None),
+    # It's important to have R1-0528 as it doesn't have the same chat template
+    ("deepseek-ai/DeepSeek-R1-0528", DeepseekV3Config, DeepseekV3ForCausalLM, torch.bfloat16, "0528"),
+    ("tiiuae/falcon-7b-instruct", FalconMambaConfig, FalconMambaForCausalLM, torch.bfloat16, None),
+    ("google/gemma-2-2b-it", Gemma2Config, Gemma2ForCausalLM, torch.bfloat16, None),
+    ("google/gemma-7b-it", GemmaConfig, GemmaForCausalLM, torch.bfloat16, None),
+    ("openai-community/gpt2", GPT2Config, GPT2LMHeadModel, torch.float32, None),
+    ("EleutherAI/pythia-14m", GPTNeoXConfig, GPTNeoXForCausalLM, torch.float16, None),
+    ("meta-llama/Meta-Llama-3-8B-Instruct", LlamaConfig, LlamaForCausalLM, torch.bfloat16, "3"),
+    ("meta-llama/Llama-3.1-8B-Instruct", LlamaConfig, LlamaForCausalLM, torch.bfloat16, "3.1"),
+    ("meta-llama/Llama-3.2-1B-Instruct", LlamaConfig, LlamaForCausalLM, torch.bfloat16, "3.2"),
+    ("mistralai/Mistral-7B-Instruct-v0.1", MistralConfig, MistralForCausalLM, torch.bfloat16, "0.1"),
+    ("mistralai/Mistral-7B-Instruct-v0.2", MistralConfig, MistralForCausalLM, torch.bfloat16, "0.2"),
+    ("facebook/opt-1.3b", OPTConfig, OPTForCausalLM, torch.float16, None),
+    ("microsoft/Phi-3.5-mini-instruct", Phi3Config, Phi3ForCausalLM, torch.bfloat16, None),
+    ("Qwen/Qwen2.5-32B-Instruct", Qwen2Config, Qwen2ForCausalLM, torch.bfloat16, "2.5"),
+    ("Qwen/Qwen2.5-Coder-0.5B", Qwen2Config, Qwen2ForCausalLM, torch.bfloat16, "2.5-Coder"),
+    ("Qwen/Qwen3-8B", Qwen3Config, Qwen3ForCausalLM, torch.bfloat16, None),
+]:
+    revision = "refs/pr/14" if model_id == "Qwen/Qwen3-8B" else "main"  # chat template with {% generation %}
+    tokenizer = AutoTokenizer.from_pretrained(model_id, revision=revision)
+    generation_config = GenerationConfig.from_pretrained(model_id, revision=revision)
+    config = config_class(
+        vocab_size=len(tokenizer.vocab),
+        hidden_size=8,
+        num_attention_heads=4,
+        num_key_value_heads=2,
+        num_hidden_layers=2,
+        intermediate_size=32,
+    )
+    model = model_class(config).to(dtype=dtype)
+    init_weights_tiny_model(model)
+    push_to_hub(model, tokenizer, generation_config, "tiny", suffix)
+
+# MoE models
+for model_id, config_class, model_class, dtype, suffix in [
+    ("Qwen/Qwen3-30B-A3B", Qwen3MoeConfig, Qwen3MoeForCausalLM, torch.bfloat16, None),
+    ("openai/gpt-oss-20b", GptOssConfig, GptOssForCausalLM, torch.bfloat16, None),
+    ("zai-org/GLM-4.5", Glm4MoeConfig, Glm4MoeForCausalLM, torch.bfloat16, None),
+]:
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    generation_config = GenerationConfig.from_pretrained(model_id)
+    kwargs = {}
+    if model_id == "zai-org/GLM-4.5":
+        kwargs["n_routed_experts"] = 4
+    elif model_id in ("Qwen/Qwen3-30B-A3B", "openai/gpt-oss-20b"):
+        kwargs["num_experts"] = 4
+
+    config = config_class(
+        vocab_size=len(tokenizer.vocab),
+        hidden_size=8,
+        num_attention_heads=4,
+        num_key_value_heads=2,
+        num_hidden_layers=2,
+        intermediate_size=32,
+        num_experts_per_tok=2,
+        **kwargs,
+    )
+    model = model_class(config).to(dtype=dtype)
+    init_weights_tiny_model(model)
+    push_to_hub(model, tokenizer, generation_config, "tiny", suffix)
+
+# Two slightly bigger models, required for vLLM testing
+tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-32B-Instruct")
+generation_config = GenerationConfig.from_pretrained("Qwen/Qwen2.5-32B-Instruct")
+config = Qwen2Config(
+    vocab_size=len(tokenizer.vocab),
+    hidden_size=128,  # increase hidden size so that hidden_size // num_attention_heads = 32, required for vLLM
+    num_attention_heads=4,
+    num_key_value_heads=2,
+    num_hidden_layers=2,
+    intermediate_size=32,
+)
+model = Qwen2ForCausalLM(config).to(dtype=torch.bfloat16)
+push_to_hub(model, tokenizer, generation_config, "small", "2.5")
+
+tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B")
+generation_config = GenerationConfig.from_pretrained("Qwen/Qwen3-4B")
+config = Qwen3Config(
+    vocab_size=len(tokenizer.vocab),
+    hidden_size=128,  # increase hidden size so that hidden_size // num_attention_heads = 32, required for vLLM
+    num_attention_heads=4,
+    num_key_value_heads=2,
+    num_hidden_layers=2,
+    intermediate_size=32,
+)
+model = Qwen3ForCausalLM(config).to(dtype=torch.bfloat16)
+push_to_hub(model, tokenizer, generation_config, "small")
+
+# Reward models
+for model_id, model_class, dtype, suffix in [
+    ("EleutherAI/pythia-14m", GPTNeoXForSequenceClassification, torch.bfloat16, None),
+    ("meta-llama/Llama-3.2-1B-Instruct", LlamaForSequenceClassification, torch.bfloat16, "3.2"),
+    ("Qwen/Qwen2.5-32B-Instruct", Qwen2ForSequenceClassification, torch.bfloat16, "2.5"),
+    ("Qwen/Qwen3-4B", Qwen3ForSequenceClassification, torch.bfloat16, None),
+]:
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    generation_config = GenerationConfig.from_pretrained(model_id)
+    kwargs = {
+        "num_labels": 1,
+        "hidden_size": 16,
+        "num_attention_heads": 4,
+        "num_key_value_heads": 2,
+        "num_hidden_layers": 2,
+        "intermediate_size": 32,
+    }
+    config = AutoConfig.from_pretrained(model_id, **kwargs)
+    # Bug in transformers: it ignores num_hidden_layers to build layer_types
+    if model_id in ("Qwen/Qwen2.5-32B-Instruct", "Qwen/Qwen3-4B"):
+        config.layer_types = config.layer_types[:2]
+    model = model_class(config).to(dtype=dtype)
+    init_weights_tiny_model(model)
+    push_to_hub(model, tokenizer, generation_config, "tiny", suffix)
+
+# MoE Reward models
+for model_id, model_class, dtype, suffix in [
+    ("Qwen/Qwen3-30B-A3B", Qwen3MoeForSequenceClassification, torch.bfloat16, None),
+]:
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    generation_config = GenerationConfig.from_pretrained(model_id)
+    kwargs = {
+        "num_labels": 1,
+        "hidden_size": 16,
+        "num_attention_heads": 4,
+        "num_key_value_heads": 2,
+        "num_hidden_layers": 2,
+        "intermediate_size": 32,
+        "num_experts": 4,
+        "num_experts_per_tok": 2,
+    }
+    config = AutoConfig.from_pretrained(model_id, **kwargs)
+    model = model_class(config).to(dtype=dtype)
+    push_to_hub(model, tokenizer, generation_config, "tiny", suffix)
+
+
+# Encoder-decoder models
+for model_id, model_class, dtype, suffix in [
+    ("facebook/bart-base", BartModel, torch.float32, None),
+    ("google/flan-t5-small", T5ForConditionalGeneration, torch.float32, None),
+]:
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    generation_config = GenerationConfig.from_pretrained(model_id) if model_id != "facebook/bart-base" else None
+    config = AutoConfig.from_pretrained(model_id)
+    config.d_model = 24
+    model = model_class(config).to(dtype=dtype)
+    push_to_hub(model, tokenizer, generation_config, "tiny", suffix)
+
+
+# Vision Language Models
+for model_id, model_class, dtype in [
+    ("google/gemma-3-4b-it", Gemma3ForConditionalGeneration, torch.bfloat16),
+    ("google/gemma-4-E2B-it", Gemma4ForConditionalGeneration, torch.bfloat16),
+    ("google/paligemma-3b-pt-224", PaliGemmaForConditionalGeneration, torch.float32),
+    ("HuggingFaceM4/idefics2-8b", Idefics2ForConditionalGeneration, torch.float32),
+    ("HuggingFaceM4/Idefics3-8B-Llama3", Idefics3ForConditionalGeneration, torch.bfloat16),
+    ("HuggingFaceTB/SmolVLM2-2.2B-Instruct", SmolVLMForConditionalGeneration, torch.float32),
+    ("llava-hf/llava-1.5-7b-hf", LlavaForConditionalGeneration, torch.float16),
+    # Original model dtype is float16, but it triggers CUDA device side assert error (see GH-4741):
+    ("llava-hf/llava-v1.6-mistral-7b-hf", LlavaNextForConditionalGeneration, torch.bfloat16),
+    ("OpenGVLab/InternVL3-8B-hf", InternVLForConditionalGeneration, torch.bfloat16),
+    ("Qwen/Qwen2-VL-2B-Instruct", Qwen2VLForConditionalGeneration, torch.bfloat16),
+    ("Qwen/Qwen2.5-VL-3B-Instruct", Qwen2_5_VLForConditionalGeneration, torch.bfloat16),
+    ("Qwen/Qwen3-VL-2B-Instruct", Qwen3VLForConditionalGeneration, torch.bfloat16),
+    ("Qwen/Qwen3.5-0.8B", Qwen3_5ForConditionalGeneration, torch.bfloat16),
+]:
+    processor = AutoProcessor.from_pretrained(model_id)
+    generation_config = GenerationConfig.from_pretrained(model_id) if model_id != "Qwen/Qwen3.5-0.8B" else None
+
+    text_config = {
+        "num_hidden_layers": 2,
+        "hidden_size": 16,
+        "num_attention_heads": 4,
+        "num_key_value_heads": 2,
+        "layer_types": None,  # Set it automatically from num_hidden_layers
+    }
+    vision_config = {
+        "num_hidden_layers": 2,
+        "hidden_size": 16,
+        "num_attention_heads": 4,
+        "num_key_value_heads": 2,
+        "embed_dim": 64,
+    }
+    kwargs = {}
+
+    if issubclass(model_class.config_class, (Qwen2VLConfig, Qwen2_5_VLConfig)):
+        text_config["rope_scaling"] = {"type": "default", "mrope_section": [1, 1], "rope_type": "default"}
+        vision_config["depth"] = 2
+        # Different dict object from text_config; see GH-4101 and transformers#41020
+        kwargs["rope_scaling"] = {"type": "default", "mrope_section": [1, 1], "rope_type": "default"}
+
+    if issubclass(model_class.config_class, Qwen2_5_VLConfig):
+        vision_config["out_hidden_size"] = 16
+        # Different dict object at the config root; see GH-4101 and transformers#41020
+        kwargs["num_hidden_layers"] = 2
+        kwargs["hidden_size"] = 16
+        kwargs["num_attention_heads"] = 4
+
+    if issubclass(model_class.config_class, Idefics2Config):
+        kwargs["perceiver_config"] = {"hidden_size": 16}
+
+    if issubclass(model_class.config_class, Qwen3VLConfig):
+        # So hasattr(config, "layer_types") is False
+        # See: https://github.com/huggingface/transformers/blob/fe5ca9ddaa07fac2872407e75c7a7661216ac956/src/transformers/models/qwen3_vl/modeling_qwen3_vl.py#L420
+        del text_config["layer_types"]
+        # "mrope_section" needs 3 elements: for dim, offset in enumerate((1, 2), start=1): mrope_section[dim]
+        # See: https://github.com/huggingface/transformers/blob/fe5ca9ddaa07fac2872407e75c7a7661216ac956/src/transformers/models/qwen3_vl/modeling_qwen3_vl.py#L361
+        text_config["rope_scaling"] = {"mrope_interleaved": True, "mrope_section": [2, 2, 2], "rope_type": "default"}
+        vision_config["depth"] = 2
+        vision_config["out_hidden_size"] = 16
+
+    if issubclass(model_class.config_class, Qwen3_5Config):
+        # For tiny layer counts, default `layer_types` can end up with no full-attention layers (e.g. 2 layers and
+        # default interval 4), which breaks Qwen3.5 dynamic cache logic. Keep one full-attention layer at the end.
+        text_config["layer_types"] = ["linear_attention", "full_attention"]
+        text_config["full_attention_interval"] = 2
+        # Qwen3.5-VL vision config expects `depth`/`num_heads`, not `num_hidden_layers`/`num_attention_heads`.
+        vision_config.pop("num_hidden_layers", None)
+        vision_config.pop("num_attention_heads", None)
+        vision_config.pop("num_key_value_heads", None)
+        vision_config.pop("embed_dim", None)
+        vision_config["depth"] = 2
+        vision_config["num_heads"] = 4
+        vision_config["intermediate_size"] = 32
+        vision_config["out_hidden_size"] = 16
+
+    if model_id == "llava-hf/llava-v1.6-mistral-7b-hf":
+        # Hotfix: llava-hf/llava-v1.6-mistral-7b-hf mistakesly sets text_config.dtype to "bfloat16".
+        # See https://huggingface.co/llava-hf/llava-v1.6-mistral-7b-hf/discussions/46
+        text_config["dtype"] = None
+
+    if model_class is Gemma4ForConditionalGeneration:
+        # Gemma4 rope validation fails when passing text_config as a dict, so we mutate the config directly.
+        config = AutoConfig.from_pretrained(model_id)
+        for k, v in text_config.items():
+            setattr(config.text_config, k, v)
+        for k, v in vision_config.items():
+            setattr(config.vision_config, k, v)
+        config.text_config.layer_types = ["sliding_attention", "full_attention"]
+        config.text_config.num_kv_shared_layers = 0
+        config.text_config.global_head_dim = 8
+        config.text_config.hidden_size_per_layer_input = 16
+        config.audio_config = None
+    else:
+        config = AutoConfig.from_pretrained(model_id, text_config=text_config, vision_config=vision_config, **kwargs)
+    model = model_class(config).to(dtype=dtype)
+
+    if issubclass(model_class.config_class, Qwen3_5Config):
+        # Qwen3.5 models has some weights in float32, to mirror this in the tiny model we need to convert them to float32 manually.
+        for layer in model.model.language_model.layers:
+            if hasattr(layer, "linear_attn"):  # applies to linear attention layers only
+                layer.linear_attn.A_log.data = layer.linear_attn.A_log.data.float()
+                layer.linear_attn.norm.weight.data = layer.linear_attn.norm.weight.data.float()
+
+    push_to_hub(model, processor, generation_config, "tiny")
+
+# PEFT models
+model = Qwen3ForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen3ForCausalLM", dtype="auto")
+model = get_peft_model(model, LoraConfig())
+generation_config = GenerationConfig.from_pretrained("trl-internal-testing/tiny-Qwen3ForCausalLM")
+push_to_hub(model, None, None, "tiny")
+
+# Same model, but different weights
+model = Qwen3ForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen3ForCausalLM", dtype="auto")
+model = get_peft_model(model, LoraConfig())
+generation_config = GenerationConfig.from_pretrained("trl-internal-testing/tiny-Qwen3ForCausalLM")
+push_to_hub(model, None, None, "tiny", "2")

tasks/tasksmith-0ea2241cceeb/environment/source/scripts/generate_toolcall_dataset.py

@@ -0,0 +1,340 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from datasets import Dataset
+from transformers import HfArgumentParser
+from transformers.utils import get_json_schema
+
+
+@dataclass
+class ScriptArguments:
+    r"""
+    Arguments for the script.
+
+    Args:
+        test_size (`float`, *optional*, defaults to `0.1`):
+            Fraction of the dataset to include in the test split.
+        push_to_hub (`bool`, *optional*, defaults to `False`):
+            Whether to push the dataset to the Hugging Face Hub.
+        repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen"`):
+            Hugging Face repository ID to push the dataset to.
+    """
+
+    test_size: float = field(
+        default=0.1,
+        metadata={"help": "Fraction of the dataset to include in the test split."},
+    )
+    push_to_hub: bool = field(
+        default=False,
+        metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+    )
+    repo_id: str = field(
+        default="trl-internal-testing/toolcall",
+        metadata={"help": "Hugging Face repository ID to push the dataset to."},
+    )
+
+
+def main(test_size, push_to_hub, repo_id):
+    # Fictitious functions to simulate tool calls
+    def start_timer(duration: int) -> int:
+        """
+        Starts a timer for the specified duration in seconds.
+
+        Args:
+            duration: Duration in seconds to set the timer for.
+
+        Returns:
+            The duration set for the timer.
+        """
+        return duration
+
+    def get_current_time(location: str) -> str:
+        """
+        Returns the current time in the specified location.
+
+        Args:
+            location: The location for which to get the current time.
+
+        Returns:
+            The current time in the specified location.
+        """
+        return "06:22:48"
+
+    def get_air_quality_index(location: str) -> int:
+        """
+        Returns the air quality index for the specified location.
+
+        Args:
+            location: The location for which to get the air quality index.
+
+        Returns:
+            The air quality index for the specified location.
+        """
+        return 53
+
+    def play_music(title: str, artist: str) -> dict:
+        """
+        Plays music by the specified title and artist.
+
+        Args:
+            title: The title of the music to play.
+            artist: The artist of the music to play.
+
+        Returns:
+            A dictionary indicating the status of the music playback.
+        """
+        return {"status": "Playing"}
+
+    def get_weather_forecast(city: str, date: str) -> dict:
+        """
+        Returns the weather forecast for the specified city and date.
+
+        Args:
+            city: The city for which to get the weather forecast.
+            date: The date for which to get the weather forecast.
+
+        Returns:
+            A dictionary containing the temperature and weather condition.
+        """
+        return {"temperature": 22, "condition": "partly cloudy"}
+
+    def control_light(room: str, state: str) -> dict:
+        """
+        Controls the light in the specified room.
+
+        Args:
+            room: The room where the light should be controlled.
+            state: The desired state of the light ("on" or "off").
+
+        Returns:
+            A dictionary indicating the state of the light.
+        """
+        return {"state": state}
+
+    def create_reminder(time: str, note: str) -> str:
+        """
+        Creates a reminder for the specified time and note.
+
+        Args:
+            time: The time for the reminder.
+            note: The note for the reminder.
+
+        Returns:
+            A confirmation message indicating that the reminder has been set.
+        """
+        return "I'll remind you to call mom at 7 PM."
+
+    def get_wind_conditions(city: str, unit: str) -> tuple[int, str]:
+        """
+        Returns the wind conditions for the specified city.
+
+        Args:
+            city: The city for which to get the wind conditions.
+            unit: The unit of measurement for the wind speed (e.g., "mph").
+
+        Returns:
+            A tuple containing the wind speed and direction.
+        """
+        return 14, "NW"
+
+    start_timer = get_json_schema(start_timer)
+    get_current_time = get_json_schema(get_current_time)
+    get_air_quality_index = get_json_schema(get_air_quality_index)
+    play_music = get_json_schema(play_music)
+    get_weather_forecast = get_json_schema(get_weather_forecast)
+    control_light = get_json_schema(control_light)
+    create_reminder = get_json_schema(create_reminder)
+    get_wind_conditions = get_json_schema(get_wind_conditions)
+
+    # fmt: off
+    language_modeling_dataset = Dataset.from_dict({
+        "messages": [
+            [
+                {"role": "user", "content": "Set a timer for 10 minutes."},
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "start_timer", "arguments": {"duration": 600}}}]},
+                {"role": "tool", "name": "start_timer", "content": "600"},
+                {"role": "assistant", "content": "Timer set for 10 minutes."},
+            ],
+            [
+                {"role": "user", "content": "What time is it in Tokyo?"},
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_current_time", "arguments": {"location": "Tokyo"}}}]},
+                {"role": "tool", "name": "get_current_time", "content": "06:22:48"},
+                {"role": "assistant", "content": "The current time in Tokyo is 06:22 AM."},
+            ],
+            [
+                {"role": "user", "content": "Is the air clean today in Lisbon?"},
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_air_quality_index", "arguments": {"location": "Lisbon, Portugal"}}}]},
+                {"role": "tool", "name": "get_air_quality_index", "content": "53"},
+                {"role": "assistant", "content": "The air quality is moderate."},
+            ],
+            [
+                {"role": "user", "content": "Play some music."},
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "play_music", "arguments": {"title": "Take Five", "artist": "Dave Brubeck"}}}]},
+                {"role": "tool", "name": "play_music", "content": "{'status': 'Playing'}"},
+                {"role": "assistant", "content": "Enjoy the jazz tunes!"},
+            ],
+            [
+                {"role": "user", "content": "What's the weather like tomorrow in Berlin?"},
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_weather_forecast", "arguments": {"city": "Berlin", "date": "2025-06-16"}}}]},
+                {"role": "tool", "name": "get_weather_forecast", "content": "{'temperature': 22, 'condition': 'partly cloudy'}"},
+                {"role": "assistant", "content": "Tomorrow in Berlin will be partly cloudy with a high of 22°C."}
+            ],
+            [
+                {"role": "user", "content": "Turn on the living room lights."},
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "control_light", "arguments": {"room": "living room", "state": "on"}}}]},
+                {"role": "tool", "name": "control_light", "content": "{'state': 'on'}"},
+                {"role": "assistant", "content": "The living room lights are now on."}
+            ],
+            [
+                {"role": "user", "content": "Remind me to call mom at 7 PM."},
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "create_reminder", "arguments": {"time": "19:00", "note": "Call mom"}}}]},
+                {"role": "tool", "name": "create_reminder", "content": "Reminder set"},
+                {"role": "assistant", "content": "Okay, I'll remind you to call mom at 7 PM."}
+            ],
+            [
+                {"role": "user", "content": "How strong is the wind in Chicago right now?"},
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_wind_conditions", "arguments": {"city": "Chicago", "unit": "mph"}}}]},
+                {"role": "tool", "name": "get_wind_conditions", "content": "(14, 'NW')"},
+                {"role": "assistant", "content": "The wind in Chicago is blowing at 14 mph from the northwest."}
+            ]
+        ],
+        "tools": [
+            [start_timer, create_reminder],
+            [get_current_time],
+            [get_air_quality_index, get_weather_forecast, get_wind_conditions],
+            [play_music, control_light],
+            [get_weather_forecast, get_wind_conditions],
+            [control_light],
+            [start_timer, create_reminder],
+            [get_weather_forecast, get_wind_conditions],
+        ]
+    }, on_mixed_types="use_json")
+    language_modeling_dataset = language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        language_modeling_dataset.push_to_hub(repo_id, config_name="language_modeling")
+
+    preference_dataset = Dataset.from_dict({
+        "prompt": [
+            [{"role": "user", "content": "Set a timer for 10 minutes."}],
+            [{"role": "user", "content": "What time is it in Tokyo?"}],
+            [{"role": "user", "content": "Is the air clean today in Lisbon?"}],
+            [{"role": "user", "content": "Play some music."}],
+            [{"role": "user", "content": "What's the weather like tomorrow in Berlin?"}],
+            [{"role": "user", "content": "Turn on the living room lights."}],
+            [{"role": "user", "content": "Remind me to call mom at 7 PM."}],
+            [{"role": "user", "content": "How strong is the wind in Chicago right now?"}],
+        ],
+        "chosen": [
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "start_timer", "arguments": {"duration": 600}}}]},
+                {"role": "tool", "name": "start_timer", "content": "600"},
+                {"role": "assistant", "content": "Timer set for 10 minutes."},
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_current_time", "arguments": {"location": "Tokyo"}}}]},
+                {"role": "tool", "name": "get_current_time", "content": "06:22:48"},
+                {"role": "assistant", "content": "The current time in Tokyo is 06:22 AM."},
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_air_quality_index", "arguments": {"location": "Lisbon, Portugal"}}}]},
+                {"role": "tool", "name": "get_air_quality_index", "content": "53"},
+                {"role": "assistant", "content": "The air quality is moderate."},
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "play_music", "arguments": {"title": "Take Five", "artist": "Dave Brubeck"}}}]},
+                {"role": "tool", "name": "play_music", "content": "{'status': 'Playing'}"},
+                {"role": "assistant", "content": "Enjoy the jazz tunes!"},
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_weather_forecast", "arguments": {"city": "Berlin", "date": "2025-06-16"}}}]},
+                {"role": "tool", "name": "get_weather_forecast", "content": "{'temperature': 22, 'condition': 'partly cloudy'}"},
+                {"role": "assistant", "content": "Tomorrow in Berlin will be partly cloudy with a high of 22°C."}
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "control_light", "arguments": {"room": "living room", "state": "on"}}}]},
+                {"role": "tool", "name": "control_light", "content": "{'state': 'on'}"},
+                {"role": "assistant", "content": "The living room lights are now on."}
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "create_reminder", "arguments": {"time": "19:00", "note": "Call mom"}}}]},
+                {"role": "tool", "name": "create_reminder", "content": "Reminder set"},
+                {"role": "assistant", "content": "Okay, I’ll remind you to call mom at 7 PM."}
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_wind_conditions", "arguments": {"city": "Chicago", "unit": "mph"}}}]},
+                {"role": "tool", "name": "get_wind_conditions", "content": "(14, 'NW')"},
+                {"role": "assistant", "content": "The wind in Chicago is blowing at 14 mph from the northwest."}
+            ],
+        ],
+        "rejected": [
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "start_timer", "arguments": {"duration": 10}}}]},
+                {"role": "tool", "name": "start_timer", "content": "10"},
+                {"role": "assistant", "content": "Timer set for 10 seconds."},
+            ],
+            [
+                {"role": "assistant", "content": "It is 6:22 AM in Tokyo."},
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_air_quality_index", "arguments": {"location": "Lisbon"}}}]},
+                {"role": "tool", "name": "get_air_quality_index", "content": "53"},
+                {"role": "assistant", "content": "The air quality is great."},
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "play_music", "arguments": {"title": "Take Five", "artist": "Daft Punk"}}}]},
+                {"role": "tool", "name": "play_music", "content": "{'status': 'Playing'}"},
+                {"role": "assistant", "content": "Playing your song."},
+            ],
+            [
+                {"role": "assistant", "content": "Tomorrow in Berlin will be hot and sunny."},
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "control_light", "arguments": {"room": "living room", "state": "off"}}}]},
+                {"role": "tool", "name": "control_light", "content": "{'state': 'off'}"},
+                {"role": "assistant", "content": "The living room lights are now off."}
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "create_reminder", "arguments": {"time": "07:00", "note": "Call mom"}}}]},
+                {"role": "tool", "name": "create_reminder", "content": "Reminder set"},
+                {"role": "assistant", "content": "Okay, I'll remind you to call mom at 7 AM."}
+            ],
+            [
+                {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_weather_forecast", "arguments": {"city": "Chicago", "date": "2025-06-16"}}}]},
+                {"role": "tool", "name": "get_weather_forecast", "content": "{'temperature': 22, 'condition': 'partly cloudy'}"},
+                {"role": "assistant", "content": "Tomorrow in Chicago will be partly cloudy with a high of 22°C."}
+            ],
+        ],
+        "tools": [
+            [start_timer],
+            [get_current_time],
+            [get_air_quality_index],
+            [play_music],
+            [get_weather_forecast],
+            [control_light],
+            [create_reminder],
+            [get_wind_conditions],
+        ],
+    }, on_mixed_types="use_json")
+    preference_dataset = preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        preference_dataset.push_to_hub(repo_id, config_name="preference")
+    # fmt: on
+
+
+if __name__ == "__main__":
+    parser = HfArgumentParser(ScriptArguments)
+    script_args = parser.parse_args_into_dataclasses()[0]
+    main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)

tasks/tasksmith-0ea2241cceeb/environment/source/scripts/generate_zen_dataset.py

@@ -0,0 +1,660 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+from datasets import Dataset
+from transformers import HfArgumentParser
+
+
+@dataclass
+class ScriptArguments:
+    r"""
+    Arguments for the script.
+
+    Args:
+        test_size (`float`, *optional*, defaults to `0.1`):
+            Fraction of the dataset to include in the test split.
+        push_to_hub (`bool`, *optional*, defaults to `False`):
+            Whether to push the dataset to the Hugging Face Hub.
+        repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen"`):
+            Hugging Face repository ID to push the dataset to.
+    """
+
+    test_size: float = field(
+        default=0.1,
+        metadata={"help": "Fraction of the dataset to include in the test split."},
+    )
+    push_to_hub: bool = field(
+        default=False,
+        metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+    )
+    repo_id: str = field(
+        default="trl-internal-testing/zen",
+        metadata={"help": "Hugging Face repository ID to push the dataset to."},
+    )
+
+
+def main(test_size, push_to_hub, repo_id):
+    # fmt: off
+    standard_language_modeling_dataset = Dataset.from_dict({
+        "text": [
+            "Beautiful is better than ugly.",
+            "Explicit is better than implicit.",
+            "Simple is better than complex.",
+            "Complex is better than complicated.",
+            "Flat is better than nested.",
+            "Sparse is better than dense.",
+            "Readability counts.",
+            "Special cases aren't special enough to break the rules.",
+            "Although practicality beats purity.",
+            "Errors should never pass silently.",
+            "Unless explicitly silenced.",
+            "In the face of ambiguity, refuse the temptation to guess.",
+            "There should be one-- and preferably only one --obvious way to do it.",
+            "Although that way may not be obvious at first unless you're Dutch.",
+            "Now is better than never.",
+            "Although never is often better than *right* now.",
+            "If the implementation is hard to explain, it's a bad idea.",
+            "If the implementation is easy to explain, it may be a good idea.",
+            "Namespaces are one honking great idea -- let's do more of those!",
+        ],
+    })
+    standard_language_modeling_dataset = standard_language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        standard_language_modeling_dataset.push_to_hub(repo_id, config_name="standard_language_modeling")
+
+    standard_prompt_only_dataset = Dataset.from_dict({
+        "prompt": [
+            "Beautiful is better than",
+            "Explicit is",
+            "Simple is better",
+            "Complex",
+            "Flat is better than",
+            "Sparse is better",
+            "Readability",
+            "Special cases aren't special",
+            "Although practicality beats",
+            "Errors should never",
+            "Unless explicitly",
+            "In the face of ambiguity, refuse",
+            "There should be one-- and preferably",
+            "Although that way may not be obvious at first unless you're",
+            "Now is",
+            "Although never is often",
+            "If the implementation is hard to explain,",
+            "If the implementation is easy",
+            "Namespaces are one honking great",
+        ],
+    })
+    standard_prompt_only_dataset = standard_prompt_only_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        standard_prompt_only_dataset.push_to_hub(repo_id, config_name="standard_prompt_only")
+
+    standard_prompt_completion_dataset = Dataset.from_dict({
+        "prompt": [
+            "Beautiful is better than",
+            "Explicit is",
+            "Simple is better",
+            "Complex",
+            "Flat is better than",
+            "Sparse is better",
+            "Readability",
+            "Special cases aren't special",
+            "Although practicality beats",
+            "Errors should never",
+            "Unless explicitly",
+            "In the face of ambiguity, refuse",
+            "There should be one-- and preferably",
+            "Although that way may not be obvious at first unless you're",
+            "Now is",
+            "Although never is often",
+            "If the implementation is hard to explain,",
+            "If the implementation is easy",
+            "Namespaces are one honking great",
+        ],
+        "completion": [
+            " ugly.",
+            " better than implicit.",
+            " than complex.",
+            " is better than complicated.",
+            " nested.",
+            " than dense.",
+            " counts.",
+            " enough to break the rules.",
+            " purity.",
+            " pass silently.",
+            " silenced.",
+            " the temptation to guess.",
+            " only one --obvious way to do it.",
+            " Dutch.",
+            " better than never.",
+            " better than *right* now.",
+            " it's a bad idea.",
+            " to explain, it may be a good idea.",
+            " idea -- let's do more of those!",
+        ],
+    })
+    standard_prompt_completion_dataset = standard_prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        standard_prompt_completion_dataset.push_to_hub(repo_id, config_name="standard_prompt_completion")
+
+    standard_preference_dataset = Dataset.from_dict({
+        "prompt": [
+            "Beautiful is better than",
+            "Explicit is",
+            "Simple is better",
+            "Complex",
+            "Flat is better than",
+            "Sparse is better",
+            "Readability",
+            "Special cases aren't special",
+            "Although practicality beats",
+            "Errors should never",
+            "Unless explicitly",
+            "In the face of ambiguity, refuse",
+            "There should be one-- and preferably",
+            "Although that way may not be obvious at first unless you're",
+            "Now is",
+            "Although never is often",
+            "If the implementation is hard to explain,",
+            "If the implementation is easy",
+            "Namespaces are one honking great",
+        ],
+        "chosen": [
+            " ugly.",
+            " better than implicit.",
+            " than complex.",
+            " is better than complicated.",
+            " nested.",
+            " than dense.",
+            " counts.",
+            " enough to break the rules.",
+            " purity.",
+            " pass silently.",
+            " silenced.",
+            " the temptation to guess.",
+            " only one --obvious way to do it.",
+            " Dutch.",
+            " better than never.",
+            " better than *right* now.",
+            " it's a bad idea.",
+            " to explain, it may be a good idea.",
+            " idea -- let's do more of those!",
+        ],
+        "rejected": [
+            " the moon.",
+            " worse than nothing.",
+            " than a long vacation.",
+            " is always the answer.",
+            " chocolate.",
+            " without any context.",
+            " is optional.",
+            " enough to become unicorns.",
+            " reality.",
+            " pass their driving test.",
+            " forgotten.",
+            " the opportunity to laugh.",
+            " two or more confusing methods.",
+            " a time traveler.",
+            " never better.",
+            " not even a possibility.",
+            " it's clearly the best choice.",
+            " it's probably magic.",
+            " watermelon -- let's plant some!",
+        ],
+    })
+    standard_preference_dataset = standard_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        standard_preference_dataset.push_to_hub(repo_id, config_name="standard_preference")
+
+    standard_implicit_prompt_preference_dataset = Dataset.from_dict({
+        "chosen": [
+            "Beautiful is better than ugly.",
+            "Explicit is better than implicit.",
+            "Simple is better than complex.",
+            "Complex is better than complicated.",
+            "Flat is better than nested.",
+            "Sparse is better than dense.",
+            "Readability counts.",
+            "Special cases aren't special enough to break the rules.",
+            "Although practicality beats purity.",
+            "Errors should never pass silently.",
+            "Unless explicitly silenced.",
+            "In the face of ambiguity, refuse the temptation to guess.",
+            "There should be one-- and preferably only one --obvious way to do it.",
+            "Although that way may not be obvious at first unless you're Dutch.",
+            "Now is better than never.",
+            "Although never is often better than *right* now.",
+            "If the implementation is hard to explain, it's a bad idea.",
+            "If the implementation is easy to explain, it may be a good idea.",
+            "Namespaces are one honking great idea -- let's do more of those!",
+        ],
+        "rejected": [
+            "Beautiful is better than the moon.",
+            "Explicit is worse than nothing.",
+            "Simple is better than a long vacation.",
+            "Complex is always the answer.",
+            "Flat is better than chocolate.",
+            "Sparse is better without any context.",
+            "Readability is optional.",
+            "Special cases aren't special enough to become unicorns.",
+            "Although practicality beats reality.",
+            "Errors should never pass their driving test.",
+            "Unless explicitly forgotten.",
+            "In the face of ambiguity, refuse the opportunity to laugh.",
+            "There should be one-- and preferably two or more confusing methods.",
+            "Although that way may not be obvious at first unless you're a time traveler.",
+            "Now is never better.",
+            "Although never is often not even a possibility.",
+            "If the implementation is hard to explain, it's clearly the best choice.",
+            "If the implementation is easy it's probably magic.",
+            "Namespaces are one honking great watermelon -- let's plant some!",
+        ],
+    })
+    standard_implicit_prompt_preference_dataset = standard_implicit_prompt_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        standard_implicit_prompt_preference_dataset.push_to_hub(repo_id, config_name="standard_implicit_prompt_preference")
+
+    standard_unpaired_preference_dataset = Dataset.from_dict({
+        "prompt": [
+            "Beautiful is better than",
+            "Explicit is",
+            "Simple is better",
+            "Complex",
+            "Flat is better than",
+            "Sparse is better",
+            "Readability",
+            "Special cases aren't special",
+            "Although practicality beats",
+            "Errors should never",
+            "Unless explicitly",
+            "In the face of ambiguity, refuse",
+            "There should be one-- and preferably",
+            "Although that way may not be obvious at first unless you're",
+            "Now is",
+            "Although never is often",
+            "If the implementation is hard to explain,",
+            "If the implementation is easy",
+            "Namespaces are one honking great",
+        ],
+        "completion": [
+            " ugly.",
+            " worse than nothing.",
+            " than a long vacation.",
+            " is better than complicated.",
+            " nested.",
+            " without any context.",
+            " counts.",
+            " enough to become unicorns.",
+            " purity.",
+            " pass silently.",
+            " forgotten.",
+            " the temptation to guess.",
+            " only one --obvious way to do it.",
+            " a time traveler.",
+            " better than never.",
+            " not even a possibility.",
+            " it's a bad idea.",
+            " it's probably magic.",
+            " watermelon -- let's plant some!",
+        ],
+        "label": [True, False, False, True, True, False, True, False, True, True, False, True, True, False, True, False, True, False, False],
+    })
+    standard_unpaired_preference_dataset = standard_unpaired_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        standard_unpaired_preference_dataset.push_to_hub(repo_id, config_name="standard_unpaired_preference")
+
+    standard_stepwise_supervision_dataset = Dataset.from_dict({
+        "prompt": [
+            "Beautiful is better than",
+            "Explicit is better than",
+            "Simple is better than",
+            "Complex is better than",
+            "Flat is better than",
+            "Sparse is better than",
+            "Readability counts",
+            "Special cases aren't special enough",
+            "Although practicality beats",
+            "Errors should never pass",
+            "In the face of ambiguity, refuse",
+            "There should be one-- and preferably only one --",
+            "Although that way may not be",
+            "Now is better than",
+            "Never is often better than",
+            "If the implementation is hard to explain, it's",
+            "If the implementation is easy to explain, it",
+            "Namespaces are one",
+            "Although practicality sometimes beats purity,",
+        ],
+        "completions": [
+            [", let me think...", " ugly."],
+            [", of course,", " implicit.", " because clarity matters."],
+            ["... let's keep it basic,", " complex."],
+            [" when needed,", " complicated."],
+            [" in terms of structure,", " nested."],
+            ["... especially for readability."],
+            [" especially when others read it."],
+            [", unless...", " they follow the rules."],
+            [" some theoretical elegance,", " purity."],
+            [" silently,", " unless explicitly silenced."],
+            [" the temptation to guess."],
+            [" way to do it,", " but sometimes it's not obvious.", " especially when there's more than one possibility."],
+            [" clear at first,", " it will eventually emerge."],
+            [" later."],
+            [" problematic fixes."],
+            [" likely because it's too complicated."],
+            [" might be a good design."],
+            [" of those great ideas,", " that solve many problems."],
+            [" the code should still aim for balance."],
+        ],
+        "labels": [
+            [False, True],
+            [False, True, False],
+            [False, True],
+            [True, True],
+            [True, False],
+            [True],
+            [False],
+            [True, False],
+            [False, False],
+            [False, False],
+            [True],
+            [True, True, False],
+            [True, True],
+            [False],
+            [True], [False],
+            [False],
+            [True, True],
+            [False]
+        ]
+    })
+    standard_stepwise_supervision_dataset = standard_stepwise_supervision_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        standard_stepwise_supervision_dataset.push_to_hub(repo_id, config_name="standard_stepwise_supervision")
+
+    conversational_language_modeling_dataset = Dataset.from_dict({
+        "messages": [
+            [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Beautiful."},],
+            [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explicit."}],
+            [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Simple."}],
+            [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Complex."}],
+            [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Flat."}],
+            [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Sparse."}],
+            [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Readability."}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Practicality."}],
+            [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Errors."}],
+            [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "When explicitly silenced."}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Refuse the temptation to guess."}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "One, and preferably only one."}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "Dutch."}],
+            [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Now is better than never."}],
+            [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "Yes, often."}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it may be a good idea."}],
+            [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Namespaces are one honking great idea."}],
+        ],
+    })
+    conversational_language_modeling_dataset = conversational_language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_language_modeling_dataset.push_to_hub(repo_id, config_name="conversational_language_modeling")
+
+    conversational_prompt_only_dataset = Dataset.from_dict({
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+    })
+    conversational_prompt_only_dataset = conversational_prompt_only_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_prompt_only_dataset.push_to_hub(repo_id, config_name="conversational_prompt_only")
+
+    conversational_prompt_completion_dataset = Dataset.from_dict({
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "completion": [
+            [{"role": "assistant", "content": "Beautiful."}],
+            [{"role": "assistant", "content": "Explicit."}],
+            [{"role": "assistant", "content": "Simple."}],
+            [{"role": "assistant", "content": "Complex."}],
+            [{"role": "assistant", "content": "Flat."}],
+            [{"role": "assistant", "content": "Sparse."}],
+            [{"role": "assistant", "content": "Readability."}],
+            [{"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "assistant", "content": "Practicality."}],
+            [{"role": "assistant", "content": "Errors."}],
+            [{"role": "assistant", "content": "When explicitly silenced."}],
+            [{"role": "assistant", "content": "Refuse the temptation to guess."}],
+            [{"role": "assistant", "content": "One, and preferably only one."}],
+            [{"role": "assistant", "content": "Dutch."}],
+            [{"role": "assistant", "content": "Now is better than never."}],
+            [{"role": "assistant", "content": "Yes, often."}],
+            [{"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "assistant", "content": "It means it may be a good idea."}],
+            [{"role": "assistant", "content": "Namespaces are one honking great idea."}],
+        ],
+    })
+    conversational_prompt_completion_dataset = conversational_prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_prompt_completion_dataset.push_to_hub(repo_id, config_name="conversational_prompt_completion")
+
+    conversational_preference_dataset = Dataset.from_dict({
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "chosen": [
+            [{"role": "assistant", "content": "Beautiful."}],
+            [{"role": "assistant", "content": "Explicit."}],
+            [{"role": "assistant", "content": "Simple."}],
+            [{"role": "assistant", "content": "Complex."}],
+            [{"role": "assistant", "content": "Flat."}],
+            [{"role": "assistant", "content": "Sparse."}],
+            [{"role": "assistant", "content": "Readability."}],
+            [{"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "assistant", "content": "Practicality."}],
+            [{"role": "assistant", "content": "Errors."}],
+            [{"role": "assistant", "content": "When explicitly silenced."}],
+            [{"role": "assistant", "content": "Refuse the temptation to guess."}],
+            [{"role": "assistant", "content": "One, and preferably only one."}],
+            [{"role": "assistant", "content": "Dutch."}],
+            [{"role": "assistant", "content": "Now is better than never."}],
+            [{"role": "assistant", "content": "Yes, often."}],
+            [{"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "assistant", "content": "It means it may be a good idea."}],
+            [{"role": "assistant", "content": "Namespaces are one honking great idea."}],
+        ],
+        "rejected": [
+            [{"role": "assistant", "content": "Acceptable."}],
+            [{"role": "assistant", "content": "Explained."}],
+            [{"role": "assistant", "content": "Very complex."}],
+            [{"role": "assistant", "content": "Very complicated."}],
+            [{"role": "assistant", "content": "Circular."}],
+            [{"role": "assistant", "content": "Heavy."}],
+            [{"role": "assistant", "content": "Looking complicated."}],
+            [{"role": "assistant", "content": "Yes, special cases are special enough to break the rules."}],
+            [{"role": "assistant", "content": "Nothing."}],
+            [{"role": "assistant", "content": "Warnings."}],
+            [{"role": "assistant", "content": "Never."}],
+            [{"role": "assistant", "content": "Give up."}],
+            [{"role": "assistant", "content": "As many as possible."}],
+            [{"role": "assistant", "content": "French."}],
+            [{"role": "assistant", "content": "Some day."}],
+            [{"role": "assistant", "content": "No, never."}],
+            [{"role": "assistant", "content": "It means it's a good idea."}],
+            [{"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "assistant", "content": "Recursion."}],
+        ],
+    })
+    conversational_preference_dataset = conversational_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_preference_dataset.push_to_hub(repo_id, config_name="conversational_preference")
+
+    conversational_implicit_prompt_preference_dataset = Dataset.from_dict({
+        "chosen": [
+            [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Beautiful."}],
+            [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explicit."}],
+            [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Simple."}],
+            [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Complex."}],
+            [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Flat."}],
+            [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Sparse."}],
+            [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Readability."}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Practicality."}],
+            [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Errors."}],
+            [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "When explicitly silenced."}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Refuse the temptation to guess."}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "One, and preferably only one."}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "Dutch."}],
+            [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Now is better than never."}],
+            [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "Yes, often."}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it may be a good idea."}],
+            [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Namespaces are one honking great idea."}],
+        ],
+        "rejected": [
+            [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Acceptable."}],
+            [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explained."}],
+            [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Very complex."}],
+            [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Very complicated."}],
+            [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Circular."}],
+            [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Heavy."}],
+            [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Looking complicated."}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "Yes, special cases are special enough to break the rules."}],
+            [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Nothing."}],
+            [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Warnings."}],
+            [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "Never."}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Give up."}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "As many as possible."}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "French."}],
+            [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Some day."}],
+            [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "No, never."}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a good idea."}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Recursion."}],
+        ],
+    })
+    conversational_implicit_prompt_preference_dataset = conversational_implicit_prompt_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_implicit_prompt_preference_dataset.push_to_hub(repo_id, config_name="conversational_implicit_prompt_preference")
+
+    conversational_unpaired_preference_dataset = Dataset.from_dict({
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "completion": [
+            [{'role': 'assistant', 'content': 'Beautiful.'}],
+            [{'role': 'assistant', 'content': 'Explicit.'}],
+            [{'role': 'assistant', 'content': 'Simple.'}],
+            [{'role': 'assistant', 'content': 'Very complicated.'}],
+            [{'role': 'assistant', 'content': 'Flat.'}],
+            [{'role': 'assistant', 'content': 'Sparse.'}],
+            [{'role': 'assistant', 'content': 'Readability.'}],
+            [{'role': 'assistant', 'content': 'Yes, special cases are special enough to break the rules.'}],
+            [{'role': 'assistant', 'content': 'Practicality.'}],
+            [{'role': 'assistant', 'content': 'Warnings.'}],
+            [{'role': 'assistant', 'content': 'When explicitly silenced.'}],
+            [{'role': 'assistant', 'content': 'Give up.'}],
+            [{'role': 'assistant', 'content': 'One, and preferably only one.'}],
+            [{'role': 'assistant', 'content': 'French.'}],
+            [{'role': 'assistant', 'content': 'Some day.'}],
+            [{'role': 'assistant', 'content': 'Yes, often.'}],
+            [{'role': 'assistant', 'content': "It means it's a bad idea."}],
+            [{'role': 'assistant', 'content': 'It means it may be a good idea.'}],
+            [{'role': 'assistant', 'content': 'Namespaces are one honking great idea.'}],
+        ],
+        "label": [True, True, True, False, True, True, True, False, True, False, True, False, True, False, False, True, True, True, True],
+    })
+    conversational_unpaired_preference_dataset = conversational_unpaired_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_unpaired_preference_dataset.push_to_hub(repo_id, config_name="conversational_unpaired_preference")
+    # fmt: on
+
+
+if __name__ == "__main__":
+    parser = HfArgumentParser(ScriptArguments)
+    script_args = parser.parse_args_into_dataclasses()[0]
+    main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)

tasks/tasksmith-0ea2241cceeb/environment/source/scripts/generate_zen_image_dataset.py

@@ -0,0 +1,346 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+import numpy as np
+from datasets import Dataset, Features, Image, Value
+from transformers import HfArgumentParser
+
+
+Message = [{"content": Value("string"), "role": Value("string")}]
+
+
+@dataclass
+class ScriptArguments:
+    r"""
+    Arguments for the script.
+
+    Args:
+        test_size (`float`, *optional*, defaults to `0.1`):
+            Fraction of the dataset to include in the test split.
+        push_to_hub (`bool`, *optional*, defaults to `False`):
+            Whether to push the dataset to the Hugging Face Hub.
+        repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen-image"`):
+            Hugging Face repository ID to push the dataset to.
+    """
+
+    test_size: float = field(
+        default=0.1,
+        metadata={"help": "Fraction of the dataset to include in the test split."},
+    )
+    push_to_hub: bool = field(
+        default=False,
+        metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+    )
+    repo_id: str = field(
+        default="trl-internal-testing/zen-image",
+        metadata={"help": "Hugging Face repository ID to push the dataset to."},
+    )
+
+
+def main(test_size, push_to_hub, repo_id):
+    # fmt: off
+    sizes = np.random.randint(32, 64, size=(19, 2))
+    data = {
+        "messages": [
+            [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Beautiful."},],
+            [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explicit."}],
+            [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Simple."}],
+            [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Complex."}],
+            [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Flat."}],
+            [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Sparse."}],
+            [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Readability."}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Practicality."}],
+            [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Errors."}],
+            [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "When explicitly silenced."}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Refuse the temptation to guess."}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "One, and preferably only one."}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "Dutch."}],
+            [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Now is better than never."}],
+            [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "Yes, often."}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it may be a good idea."}],
+            [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Namespaces are one honking great idea."}],
+        ],
+        "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+    }
+    conversational_language_modeling_dataset = Dataset.from_dict(data, features=Features(messages=Message, image=Image()))
+    conversational_language_modeling_dataset = conversational_language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_language_modeling_dataset.push_to_hub(repo_id, config_name="conversational_language_modeling")
+
+    sizes = np.random.randint(32, 64, size=(19, 2))
+    data = {
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+    }
+    conversational_prompt_only_dataset = Dataset.from_dict(data, features=Features(prompt=Message, image=Image()))
+    conversational_prompt_only_dataset = conversational_prompt_only_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_prompt_only_dataset.push_to_hub(repo_id, config_name="conversational_prompt_only")
+
+    sizes = np.random.randint(32, 64, size=(19, 2))
+    data = {
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "completion": [
+            [{"role": "assistant", "content": "Beautiful."}],
+            [{"role": "assistant", "content": "Explicit."}],
+            [{"role": "assistant", "content": "Simple."}],
+            [{"role": "assistant", "content": "Complex."}],
+            [{"role": "assistant", "content": "Flat."}],
+            [{"role": "assistant", "content": "Sparse."}],
+            [{"role": "assistant", "content": "Readability."}],
+            [{"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "assistant", "content": "Practicality."}],
+            [{"role": "assistant", "content": "Errors."}],
+            [{"role": "assistant", "content": "When explicitly silenced."}],
+            [{"role": "assistant", "content": "Refuse the temptation to guess."}],
+            [{"role": "assistant", "content": "One, and preferably only one."}],
+            [{"role": "assistant", "content": "Dutch."}],
+            [{"role": "assistant", "content": "Now is better than never."}],
+            [{"role": "assistant", "content": "Yes, often."}],
+            [{"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "assistant", "content": "It means it may be a good idea."}],
+            [{"role": "assistant", "content": "Namespaces are one honking great idea."}],
+        ],
+        "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+    }
+    conversational_prompt_completion_dataset = Dataset.from_dict(data, features=Features(prompt=Message, completion=Message, image=Image()))
+    conversational_prompt_completion_dataset = conversational_prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_prompt_completion_dataset.push_to_hub(repo_id, config_name="conversational_prompt_completion")
+
+    sizes = np.random.randint(32, 64, size=(19, 2))
+    data = {
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "chosen": [
+            [{"role": "assistant", "content": "Beautiful."}],
+            [{"role": "assistant", "content": "Explicit."}],
+            [{"role": "assistant", "content": "Simple."}],
+            [{"role": "assistant", "content": "Complex."}],
+            [{"role": "assistant", "content": "Flat."}],
+            [{"role": "assistant", "content": "Sparse."}],
+            [{"role": "assistant", "content": "Readability."}],
+            [{"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "assistant", "content": "Practicality."}],
+            [{"role": "assistant", "content": "Errors."}],
+            [{"role": "assistant", "content": "When explicitly silenced."}],
+            [{"role": "assistant", "content": "Refuse the temptation to guess."}],
+            [{"role": "assistant", "content": "One, and preferably only one."}],
+            [{"role": "assistant", "content": "Dutch."}],
+            [{"role": "assistant", "content": "Now is better than never."}],
+            [{"role": "assistant", "content": "Yes, often."}],
+            [{"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "assistant", "content": "It means it may be a good idea."}],
+            [{"role": "assistant", "content": "Namespaces are one honking great idea."}],
+        ],
+        "rejected": [
+            [{"role": "assistant", "content": "Acceptable."}],
+            [{"role": "assistant", "content": "Explained."}],
+            [{"role": "assistant", "content": "Very complex."}],
+            [{"role": "assistant", "content": "Very complicated."}],
+            [{"role": "assistant", "content": "Circular."}],
+            [{"role": "assistant", "content": "Heavy."}],
+            [{"role": "assistant", "content": "Looking complicated."}],
+            [{"role": "assistant", "content": "Yes, special cases are special enough to break the rules."}],
+            [{"role": "assistant", "content": "Nothing."}],
+            [{"role": "assistant", "content": "Warnings."}],
+            [{"role": "assistant", "content": "Never."}],
+            [{"role": "assistant", "content": "Give up."}],
+            [{"role": "assistant", "content": "As many as possible."}],
+            [{"role": "assistant", "content": "French."}],
+            [{"role": "assistant", "content": "Some day."}],
+            [{"role": "assistant", "content": "No, never."}],
+            [{"role": "assistant", "content": "It means it's a good idea."}],
+            [{"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "assistant", "content": "Recursion."}],
+        ],
+        "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+    }
+    conversational_preference_dataset = Dataset.from_dict(data, features=Features(prompt=Message, chosen=Message, rejected=Message, image=Image()))
+    conversational_preference_dataset = conversational_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_preference_dataset.push_to_hub(repo_id, config_name="conversational_preference")
+
+    sizes = np.random.randint(32, 64, size=(19, 2))
+    data = {
+        "chosen": [
+            [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Beautiful."}],
+            [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explicit."}],
+            [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Simple."}],
+            [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Complex."}],
+            [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Flat."}],
+            [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Sparse."}],
+            [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Readability."}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "No, special cases aren't special enough to break the rules."}],
+            [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Practicality."}],
+            [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Errors."}],
+            [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "When explicitly silenced."}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Refuse the temptation to guess."}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "One, and preferably only one."}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "Dutch."}],
+            [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Now is better than never."}],
+            [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "Yes, often."}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it may be a good idea."}],
+            [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Namespaces are one honking great idea."}],
+        ],
+        "rejected": [
+            [{"role": "user", "content": "What is better than ugly?"}, {"role": "assistant", "content": "Acceptable."}],
+            [{"role": "user", "content": "What is better than implicit?"}, {"role": "assistant", "content": "Explained."}],
+            [{"role": "user", "content": "What is better than complex?"}, {"role": "assistant", "content": "Very complex."}],
+            [{"role": "user", "content": "What is better than complicated?"}, {"role": "assistant", "content": "Very complicated."}],
+            [{"role": "user", "content": "What is better than nested?"}, {"role": "assistant", "content": "Circular."}],
+            [{"role": "user", "content": "What is better than dense?"}, {"role": "assistant", "content": "Heavy."}],
+            [{"role": "user", "content": "What counts?"}, {"role": "assistant", "content": "Looking complicated."}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}, {"role": "assistant", "content": "Yes, special cases are special enough to break the rules."}],
+            [{"role": "user", "content": "What beats purity?"}, {"role": "assistant", "content": "Nothing."}],
+            [{"role": "user", "content": "What should never pass silently?"}, {"role": "assistant", "content": "Warnings."}],
+            [{"role": "user", "content": "When can errors pass silently?"}, {"role": "assistant", "content": "Never."}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}, {"role": "assistant", "content": "Give up."}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}, {"role": "assistant", "content": "As many as possible."}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}, {"role": "assistant", "content": "French."}],
+            [{"role": "user", "content": "What is better than never?"}, {"role": "assistant", "content": "Some day."}],
+            [{"role": "user", "content": "Is never better than *right* now?"}, {"role": "assistant", "content": "No, never."}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}, {"role": "assistant", "content": "It means it's a good idea."}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}, {"role": "assistant", "content": "It means it's a bad idea."}],
+            [{"role": "user", "content": "Any great ideas?"}, {"role": "assistant", "content": "Recursion."}],
+        ],
+        "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+    }
+    conversational_implicit_prompt_preference_dataset = Dataset.from_dict(data, features=Features(chosen=Message, rejected=Message, image=Image()))
+    conversational_implicit_prompt_preference_dataset = conversational_implicit_prompt_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_implicit_prompt_preference_dataset.push_to_hub(repo_id, config_name="conversational_implicit_prompt_preference")
+
+    sizes = np.random.randint(32, 64, size=(19, 2))
+    data = {
+        "prompt": [
+            [{"role": "user", "content": "What is better than ugly?"}],
+            [{"role": "user", "content": "What is better than implicit?"}],
+            [{"role": "user", "content": "What is better than complex?"}],
+            [{"role": "user", "content": "What is better than complicated?"}],
+            [{"role": "user", "content": "What is better than nested?"}],
+            [{"role": "user", "content": "What is better than dense?"}],
+            [{"role": "user", "content": "What counts?"}],
+            [{"role": "user", "content": "Are special cases enough to break the rules?"}],
+            [{"role": "user", "content": "What beats purity?"}],
+            [{"role": "user", "content": "What should never pass silently?"}],
+            [{"role": "user", "content": "When can errors pass silently?"}],
+            [{"role": "user", "content": "What should you do in the face of ambiguity?"}],
+            [{"role": "user", "content": "How many ways should there be to do it?"}],
+            [{"role": "user", "content": "For whom may the way not be obvious at first?"}],
+            [{"role": "user", "content": "What is better than never?"}],
+            [{"role": "user", "content": "Is never better than *right* now?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is hard to explain?"}],
+            [{"role": "user", "content": "What does it mean if the implementation is easy to explain?"}],
+            [{"role": "user", "content": "Any great ideas?"}],
+        ],
+        "completion": [
+            [{'role': 'assistant', 'content': 'Beautiful.'}],
+            [{'role': 'assistant', 'content': 'Explicit.'}],
+            [{'role': 'assistant', 'content': 'Simple.'}],
+            [{'role': 'assistant', 'content': 'Very complicated.'}],
+            [{'role': 'assistant', 'content': 'Flat.'}],
+            [{'role': 'assistant', 'content': 'Sparse.'}],
+            [{'role': 'assistant', 'content': 'Readability.'}],
+            [{'role': 'assistant', 'content': 'Yes, special cases are special enough to break the rules.'}],
+            [{'role': 'assistant', 'content': 'Practicality.'}],
+            [{'role': 'assistant', 'content': 'Warnings.'}],
+            [{'role': 'assistant', 'content': 'When explicitly silenced.'}],
+            [{'role': 'assistant', 'content': 'Give up.'}],
+            [{'role': 'assistant', 'content': 'One, and preferably only one.'}],
+            [{'role': 'assistant', 'content': 'French.'}],
+            [{'role': 'assistant', 'content': 'Some day.'}],
+            [{'role': 'assistant', 'content': 'Yes, often.'}],
+            [{'role': 'assistant', 'content': "It means it's a bad idea."}],
+            [{'role': 'assistant', 'content': 'It means it may be a good idea.'}],
+            [{'role': 'assistant', 'content': 'Namespaces are one honking great idea.'}],
+        ],
+        "label": [True, True, True, False, True, True, True, False, True, False, True, False, True, False, False, True, True, True, True],
+        "image": [np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in sizes],
+    }
+    conversational_unpaired_preference_dataset = Dataset.from_dict(data, features=Features(prompt=Message, completion=Message, label=Value("bool"), image=Image()))
+    conversational_unpaired_preference_dataset = conversational_unpaired_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_unpaired_preference_dataset.push_to_hub(repo_id, config_name="conversational_unpaired_preference")
+    # fmt: on
+
+
+if __name__ == "__main__":
+    parser = HfArgumentParser(ScriptArguments)
+    script_args = parser.parse_args_into_dataclasses()[0]
+    main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)

tasks/tasksmith-0ea2241cceeb/environment/source/scripts/generate_zen_multi_image_dataset.py

@@ -0,0 +1,243 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+
+import numpy as np
+from datasets import Dataset, Features, Image, List, Value
+from transformers import HfArgumentParser
+
+
+Message = List({"content": List({"text": Value("string"), "type": Value("string")}), "role": Value("string")})
+
+
+@dataclass
+class ScriptArguments:
+    r"""
+    Arguments for the script.
+
+    Args:
+        test_size (`float`, *optional*, defaults to `0.1`):
+            Fraction of the dataset to include in the test split.
+        push_to_hub (`bool`, *optional*, defaults to `False`):
+            Whether to push the dataset to the Hugging Face Hub.
+        repo_id (`str`, *optional*, defaults to `"trl-internal-testing/zen-multi-image"`):
+            Hugging Face repository ID to push the dataset to.
+    """
+
+    test_size: float = field(
+        default=0.1,
+        metadata={"help": "Fraction of the dataset to include in the test split."},
+    )
+    push_to_hub: bool = field(
+        default=False,
+        metadata={"help": "Whether to push the dataset to the Hugging Face Hub."},
+    )
+    repo_id: str = field(
+        default="trl-internal-testing/zen-multi-image",
+        metadata={"help": "Hugging Face repository ID to push the dataset to."},
+    )
+
+
+def main(test_size, push_to_hub, repo_id):
+    # fmt: off
+    messages = [
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than ugly?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Beautiful."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than implicit?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Explicit."}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text":  "What is better than complex?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Simple."}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What is better than complicated?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Complex."}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than nested?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Flat."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than dense?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Sparse."}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What counts?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Readability."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Are special cases enough to break the rules?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "No, special cases aren't special enough to break the rules."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What beats purity?"}, {"type": "image"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Practicality."}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What should never pass silently?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Errors."}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "When can errors pass silently?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "When explicitly silenced."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What should you do in the face of ambiguity?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Refuse the temptation to guess."}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "How many ways should there be to do it?"}, {"type": "image"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "One, and preferably only one."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "For whom may the way not be obvious at first?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Dutch."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than never?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Now is better than never."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Is"}, {"type": "image"}, {"type": "text", "text": " never better than *right* now?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Yes, often."}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What does it mean if the implementation is hard to explain?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "It means it's a bad idea."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What does it mean if the implementation is easy to explain?"}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "It means it may be a good idea."}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Any great ideas?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "Namespaces are one honking great idea."}]}],
+    ]
+    # Create the images
+    number_of_images = [sum(1 for part in row[0]["content"] if part.get("type") == "image") for row in messages]
+    sizes = [np.random.randint(32, 64, size=(num_images, 2)) for num_images in number_of_images]
+    images = [[np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in s] for s in sizes]
+    conversational_language_modeling_dataset = Dataset.from_dict({"messages": messages, "images": images}, features=Features(messages=Message, images=List(Image())))
+    conversational_language_modeling_dataset = conversational_language_modeling_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_language_modeling_dataset.push_to_hub(repo_id, config_name="conversational_language_modeling")
+
+    prompt = [
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than ugly?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than implicit?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text":  "What is better than complex?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What is better than complicated?"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than nested?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than dense?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What counts?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Are special cases enough to break the rules?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What beats purity?"}, {"type": "image"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What should never pass silently?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "When can errors pass silently?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What should you do in the face of ambiguity?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "How many ways should there be to do it?"}, {"type": "image"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "For whom may the way not be obvious at first?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than never?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Is"}, {"type": "image"}, {"type": "text", "text": " never better than *right* now?"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What does it mean if the implementation is hard to explain?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What does it mean if the implementation is easy to explain?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Any great ideas?"}]}],
+    ]
+    # Create the images
+    number_of_images = [sum(1 for part in row[0]["content"] if part.get("type") == "image") for row in prompt]
+    sizes = [np.random.randint(32, 64, size=(num_images, 2)) for num_images in number_of_images]
+    images = [[np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in s] for s in sizes]
+    conversational_prompt_only_dataset = Dataset.from_dict({"prompt": prompt, "images": images}, features=Features(prompt=Message, images=List(Image())))
+    conversational_prompt_only_dataset = conversational_prompt_only_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_prompt_only_dataset.push_to_hub(repo_id, config_name="conversational_prompt_only")
+
+    prompt = [
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than ugly?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than implicit?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text":  "What is better than complex?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What is better than complicated?"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than nested?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than dense?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What counts?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Are special cases enough to break the rules?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What beats purity?"}, {"type": "image"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What should never pass silently?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "When can errors pass silently?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What should you do in the face of ambiguity?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "How many ways should there be to do it?"}, {"type": "image"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "For whom may the way not be obvious at first?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than never?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Is"}, {"type": "image"}, {"type": "text", "text": " never better than *right* now?"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What does it mean if the implementation is hard to explain?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What does it mean if the implementation is easy to explain?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Any great ideas?"}]}],
+    ]
+    completion = [
+        [{"role": "assistant", "content": [{"type": "text", "text": "Beautiful."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Explicit."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Simple."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Complex."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Flat."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Sparse."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Readability."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "No, special cases aren't special enough to break the rules."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Practicality."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Errors."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "When explicitly silenced."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Refuse the temptation to guess."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "One, and preferably only one."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Dutch."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Now is better than never."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Yes, often."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "It means it's a bad idea."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "It means it may be a good idea."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Namespaces are one honking great idea."}]}],
+    ]
+    # Create the images
+    number_of_images = [sum(1 for part in row[0]["content"] if part.get("type") == "image") for row in prompt]
+    sizes = [np.random.randint(32, 64, size=(num_images, 2)) for num_images in number_of_images]
+    images = [[np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in s] for s in sizes]
+    conversational_prompt_completion_dataset = Dataset.from_dict({"prompt": prompt, "completion": completion, "images": images}, features=Features(prompt=Message, completion=Message, images=List(Image())))
+    conversational_prompt_completion_dataset = conversational_prompt_completion_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_prompt_completion_dataset.push_to_hub(repo_id, config_name="conversational_prompt_completion")
+
+    prompt = [
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than ugly?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than implicit?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text":  "What is better than complex?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What is better than complicated?"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What is better than nested?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than dense?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What counts?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Are special cases enough to break the rules?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What beats purity?"}, {"type": "image"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "image"}, {"type": "text", "text": "What should never pass silently?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "When can errors pass silently?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What should you do in the face of ambiguity?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "How many ways should there be to do it?"}, {"type": "image"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "For whom may the way not be obvious at first?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What is better than never?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Is"}, {"type": "image"}, {"type": "text", "text": " never better than *right* now?"}]}],
+        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What does it mean if the implementation is hard to explain?"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "What does it mean if the implementation is easy to explain?"}, {"type": "image"}]}],
+        [{"role": "user", "content": [{"type": "text", "text": "Any great ideas?"}]}],
+    ]
+    chosen = [
+        [{"role": "assistant", "content": [{"type": "text", "text": "Beautiful."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Explicit."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Simple."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Complex."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Flat."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Sparse."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Readability."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "No, special cases aren't special enough to break the rules."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Practicality."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Errors."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "When explicitly silenced."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Refuse the temptation to guess."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "One, and preferably only one."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Dutch."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Now is better than never."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Yes, often."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "It means it's a bad idea."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "It means it may be a good idea."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Namespaces are one honking great idea."}]}],
+    ]
+    rejected = [
+        [{"role": "assistant", "content": [{"type": "text", "text": "Acceptable."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Explained."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Very complex."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Very complicated."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Circular."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Heavy."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Looking complicated."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Yes, special cases are special enough to break the rules."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Nothing."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Warnings."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Never."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Give up."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "As many as possible."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "French."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Some day."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "No, never."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "It means it's a good idea."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "It means it's a bad idea."}]}],
+        [{"role": "assistant", "content": [{"type": "text", "text": "Recursion."}]}],
+    ]
+    # Create the images
+    number_of_images = [sum(1 for part in row[0]["content"] if part.get("type") == "image") for row in prompt]
+    sizes = [np.random.randint(32, 64, size=(num_images, 2)) for num_images in number_of_images]
+    images = [[np.random.uniform(low=0.0, high=255.0, size=(h, w, 3)).astype(np.uint8) for h, w in s] for s in sizes]
+    conversational_preference_dataset = Dataset.from_dict({"prompt": prompt, "chosen": chosen, "rejected": rejected, "images": images}, features=Features(prompt=Message, chosen=Message, rejected=Message, images=List(Image())))
+    conversational_preference_dataset = conversational_preference_dataset.train_test_split(test_size=test_size, shuffle=False)
+    if push_to_hub:
+        conversational_preference_dataset.push_to_hub(repo_id, config_name="conversational_preference")
+    # fmt: on
+
+
+if __name__ == "__main__":
+    parser = HfArgumentParser(ScriptArguments)
+    script_args = parser.parse_args_into_dataclasses()[0]
+    main(script_args.test_size, script_args.push_to_hub, script_args.repo_id)

tasks/tasksmith-0ea2241cceeb/environment/source/scripts/log_reports.py

@@ -0,0 +1,169 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import json
+import logging
+import os
+from datetime import date
+from pathlib import Path
+
+from tabulate import tabulate
+
+
+MAX_LEN_MESSAGE = 2900  # Slack endpoint has a limit of 3001 characters
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--slack_channel_name", default="trl-push-ci")
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+
+def process_log_file(log):
+    failed_tests = []
+    passed_tests = []
+    section_num_failed = 0
+
+    try:
+        with open(log) as f:
+            for line in f:
+                try:
+                    data = json.loads(line)
+                    test_name = data.get("nodeid", "")
+                    duration = f"{data['duration']:.4f}" if "duration" in data else "N/A"
+                    outcome = data.get("outcome", "")
+
+                    if test_name:
+                        if outcome == "failed":
+                            section_num_failed += 1
+                            failed_tests.append([test_name, duration, log.stem.split("_")[0]])
+                        else:
+                            passed_tests.append([test_name, duration, log.stem.split("_")[0]])
+                except json.JSONDecodeError as e:
+                    logging.warning(f"Could not decode line in {log}: {e}")
+
+    except FileNotFoundError as e:
+        logging.error(f"Log file {log} not found: {e}")
+    except Exception as e:
+        logging.error(f"Error processing log file {log}: {e}")
+
+    return failed_tests, passed_tests, section_num_failed
+
+
+def main(slack_channel_name):
+    group_info = []
+    total_num_failed = 0
+    total_empty_files = []
+
+    log_files = list(Path().glob("*.log"))
+    if not log_files:
+        logging.info("No log files found.")
+        return
+
+    for log in log_files:
+        failed, passed, section_num_failed = process_log_file(log)
+        empty_file = not failed and not passed
+
+        total_num_failed += section_num_failed
+        total_empty_files.append(empty_file)
+        group_info.append([str(log), section_num_failed, failed])
+
+        # Clean up log file
+        try:
+            os.remove(log)
+        except OSError as e:
+            logging.warning(f"Could not remove log file {log}: {e}")
+
+    # Prepare Slack message payload
+    payload = [
+        {
+            "type": "header",
+            "text": {"type": "plain_text", "text": f"🤗 Results of the {os.environ.get('TEST_TYPE', '')} TRL tests."},
+        },
+    ]
+
+    if total_num_failed > 0:
+        message = ""
+        for name, num_failed, failed_tests in group_info:
+            if num_failed > 0:
+                message += f"*{name}: {num_failed} failed test(s)*\n"
+                failed_table = [
+                    test[0].split("::")[:2] + [test[0].split("::")[-1][:30] + ".."] for test in failed_tests
+                ]
+                message += (
+                    "\n```\n"
+                    + tabulate(failed_table, headers=["Test Location", "Test Name"], tablefmt="grid")
+                    + "\n```\n"
+                )
+
+            if any(total_empty_files):
+                message += f"\n*{name}: Warning! Empty file - check GitHub action job*\n"
+
+        # Logging
+        logging.info(f"Total failed tests: {total_num_failed}")
+        print(f"### {message}")
+
+        if len(message) > MAX_LEN_MESSAGE:
+            message = (
+                f"❌ There are {total_num_failed} failed tests in total! Please check the action results directly."
+            )
+
+        payload.append({"type": "section", "text": {"type": "mrkdwn", "text": message}})
+        payload.append(
+            {
+                "type": "section",
+                "text": {"type": "mrkdwn", "text": "*For more details:*"},
+                "accessory": {
+                    "type": "button",
+                    "text": {"type": "plain_text", "text": "Check Action results"},
+                    "url": f"https://github.com/huggingface/trl/actions/runs/{os.environ['GITHUB_RUN_ID']}",
+                },
+            }
+        )
+        payload.append(
+            {
+                "type": "context",
+                "elements": [
+                    {
+                        "type": "plain_text",
+                        "text": f"On Push main {os.environ.get('TEST_TYPE')} results for {date.today()}",
+                    }
+                ],
+            }
+        )
+
+        # Send to Slack
+        from slack_sdk import WebClient
+
+        slack_client = WebClient(token=os.environ.get("SLACK_API_TOKEN"))
+        slack_client.chat_postMessage(channel=f"#{slack_channel_name}", text=message, blocks=payload)
+
+    else:
+        payload.append(
+            {
+                "type": "section",
+                "text": {
+                    "type": "plain_text",
+                    "text": "✅ No failures! All tests passed successfully.",
+                    "emoji": True,
+                },
+            }
+        )
+        logging.info("All tests passed. No errors detected.")
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    main(args.slack_channel_name)

tasks/tasksmith-0ea2241cceeb/environment/source/trl.egg-info/PKG-INFO

@@ -0,0 +1,295 @@
+Metadata-Version: 2.4
+Name: trl
+Version: 1.1.0.dev0
+Summary: Train transformer language models with reinforcement learning.
+Author-email: Leandro von Werra <leandro.vonwerra@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/huggingface/trl
+Keywords: transformers,huggingface,language modeling,post-training,rlhf,sft,dpo,grpo
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: accelerate>=1.4.0
+Requires-Dist: datasets>=4.7.0
+Requires-Dist: jinja2
+Requires-Dist: packaging>20.0
+Requires-Dist: transformers>=4.56.2
+Provides-Extra: bco
+Requires-Dist: scikit-learn; extra == "bco"
+Requires-Dist: joblib; extra == "bco"
+Provides-Extra: deepspeed
+Requires-Dist: deepspeed>=0.14.4; extra == "deepspeed"
+Requires-Dist: transformers!=5.1.0; extra == "deepspeed"
+Provides-Extra: judges
+Requires-Dist: openai>=1.23.2; extra == "judges"
+Requires-Dist: llm-blender>=0.0.2; extra == "judges"
+Requires-Dist: transformers<5.0.0; extra == "judges"
+Provides-Extra: kernels
+Requires-Dist: kernels; extra == "kernels"
+Provides-Extra: liger
+Requires-Dist: liger-kernel>=0.7.0; extra == "liger"
+Provides-Extra: peft
+Requires-Dist: peft>=0.8.0; extra == "peft"
+Provides-Extra: quality
+Requires-Dist: pre-commit; extra == "quality"
+Requires-Dist: hf-doc-builder; extra == "quality"
+Provides-Extra: quantization
+Requires-Dist: bitsandbytes; extra == "quantization"
+Provides-Extra: scikit
+Requires-Dist: scikit-learn; extra == "scikit"
+Provides-Extra: test
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-datadir>=1.7.0; extra == "test"
+Requires-Dist: pytest-rerunfailures==15.1; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: vllm
+Requires-Dist: vllm<=0.17.1,>=0.11.0; extra == "vllm"
+Requires-Dist: fastapi; extra == "vllm"
+Requires-Dist: pydantic; extra == "vllm"
+Requires-Dist: aiohttp>=3.13.3; extra == "vllm"
+Requires-Dist: requests; extra == "vllm"
+Requires-Dist: uvicorn; extra == "vllm"
+Provides-Extra: vlm
+Requires-Dist: Pillow; extra == "vlm"
+Requires-Dist: torchvision; extra == "vlm"
+Requires-Dist: num2words==0.5.14; extra == "vlm"
+Provides-Extra: math-verify
+Requires-Dist: math-verify>=0.5.2; extra == "math-verify"
+Provides-Extra: dev
+Requires-Dist: scikit-learn; extra == "dev"
+Requires-Dist: joblib; extra == "dev"
+Requires-Dist: deepspeed>=0.14.4; extra == "dev"
+Requires-Dist: openai>=1.23.2; extra == "dev"
+Requires-Dist: llm-blender>=0.0.2; extra == "dev"
+Requires-Dist: kernels; extra == "dev"
+Requires-Dist: liger-kernel>=0.7.0; extra == "dev"
+Requires-Dist: peft>=0.8.0; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: hf-doc-builder; extra == "dev"
+Requires-Dist: bitsandbytes; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-datadir>=1.7.0; extra == "dev"
+Requires-Dist: pytest-rerunfailures==15.1; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: Pillow; extra == "dev"
+Requires-Dist: torchvision; extra == "dev"
+Requires-Dist: num2words==0.5.14; extra == "dev"
+Requires-Dist: jmespath; extra == "dev"
+Dynamic: license-file
+
+# TRL - Transformers Reinforcement Learning
+
+<div style="text-align: center">
+    <picture>
+        <source media="(prefers-color-scheme: light)" srcset="https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/TRL%20banner%20light.png">
+        <img src="https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/trl_banner_dark.png" alt="TRL Banner">
+    </picture>
+</div>
+
+<hr> <br>
+
+<h3 align="center">
+    <p>A comprehensive library to post-train foundation models</p>
+</h3>
+
+<p align="center">
+    <a href="https://github.com/huggingface/trl/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/huggingface/trl.svg?color=blue"></a>
+    <a href="https://huggingface.co/docs/trl/index"><img alt="Documentation" src="https://img.shields.io/website?label=documentation&url=https%3A%2F%2Fhuggingface.co%2Fdocs%2Ftrl%2Findex&down_color=red&down_message=offline&up_color=blue&up_message=online"></a>
+    <a href="https://github.com/huggingface/trl/releases"><img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/trl.svg"></a>
+    <a href="https://huggingface.co/trl-lib"><img alt="Hugging Face Hub" src="https://img.shields.io/badge/🤗%20Hub-trl--lib-yellow"></a>
+</p>
+
+## 🎉 What's New
+
+**TRL v1:** We released TRL v1 — a major milestone that marks a real shift in what TRL is. Read the [blog post](https://huggingface.co/blog/trl-v1) to learn more.
+
+## Overview
+
+TRL is a cutting-edge library designed for post-training foundation models using advanced techniques like Supervised Fine-Tuning (SFT), Group Relative Policy Optimization (GRPO), and Direct Preference Optimization (DPO). Built on top of the [🤗 Transformers](https://github.com/huggingface/transformers) ecosystem, TRL supports a variety of model architectures and modalities, and can be scaled-up across various hardware setups.
+
+## Highlights
+
+- **Trainers**: Various fine-tuning methods are easily accessible via trainers like [`SFTTrainer`](https://huggingface.co/docs/trl/sft_trainer), [`GRPOTrainer`](https://huggingface.co/docs/trl/grpo_trainer), [`DPOTrainer`](https://huggingface.co/docs/trl/dpo_trainer), [`RewardTrainer`](https://huggingface.co/docs/trl/reward_trainer) and more.
+
+- **Efficient and scalable**:
+  - Leverages [🤗 Accelerate](https://github.com/huggingface/accelerate) to scale from single GPU to multi-node clusters using methods like [DDP](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) and [DeepSpeed](https://github.com/deepspeedai/DeepSpeed).
+  - Full integration with [🤗 PEFT](https://github.com/huggingface/peft) enables training on large models with modest hardware via quantization and LoRA/QLoRA.
+  - Integrates [🦥 Unsloth](https://github.com/unslothai/unsloth) for accelerating training using optimized kernels.
+
+- **Command Line Interface (CLI)**: A simple interface lets you fine-tune with models without needing to write code.
+
+## Installation
+
+### Python Package
+
+Install the library using `pip`:
+
+```bash
+pip install trl
+```
+
+### From source
+
+If you want to use the latest features before an official release, you can install TRL from source:
+
+```bash
+pip install git+https://github.com/huggingface/trl.git
+```
+
+### Repository
+
+If you want to use the examples you can clone the repository with the following command:
+
+```bash
+git clone https://github.com/huggingface/trl.git
+```
+
+## Quick Start
+
+For more flexibility and control over training, TRL provides dedicated trainer classes to post-train language models or PEFT adapters on a custom dataset. Each trainer in TRL is a light wrapper around the 🤗 Transformers trainer and natively supports distributed training methods like DDP, DeepSpeed ZeRO, and FSDP.
+
+### `SFTTrainer`
+
+Here is a basic example of how to use the [`SFTTrainer`](https://huggingface.co/docs/trl/sft_trainer):
+
+```python
+from trl import SFTTrainer
+from datasets import load_dataset
+
+dataset = load_dataset("trl-lib/Capybara", split="train")
+
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset,
+)
+trainer.train()
+```
+
+### `GRPOTrainer`
+
+[`GRPOTrainer`](https://huggingface.co/docs/trl/grpo_trainer) implements the [Group Relative Policy Optimization (GRPO) algorithm](https://huggingface.co/papers/2402.03300) that is more memory-efficient than PPO and was used to train [Deepseek AI's R1](https://huggingface.co/deepseek-ai/DeepSeek-R1).
+
+```python
+from datasets import load_dataset
+from trl import GRPOTrainer
+from trl.rewards import accuracy_reward
+
+dataset = load_dataset("trl-lib/DeepMath-103K", split="train")
+
+trainer = GRPOTrainer(
+    model="Qwen/Qwen2.5-0.5B-Instruct",
+    reward_funcs=accuracy_reward,
+    train_dataset=dataset,
+)
+trainer.train()
+```
+
+> [!NOTE]
+> For reasoning models, use the `reasoning_accuracy_reward()` function for better results.
+
+### `DPOTrainer`
+
+[`DPOTrainer`](https://huggingface.co/docs/trl/dpo_trainer) implements the popular [Direct Preference Optimization (DPO) algorithm](https://huggingface.co/papers/2305.18290) that was used to post-train [Llama 3](https://huggingface.co/papers/2407.21783) and many other models. Here is a basic example of how to use the `DPOTrainer`:
+
+```python
+from datasets import load_dataset
+from trl import DPOTrainer
+
+dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
+
+trainer = DPOTrainer(
+    model="Qwen3/Qwen-0.6B",
+    train_dataset=dataset,
+)
+trainer.train()
+```
+
+### `RewardTrainer`
+
+Here is a basic example of how to use the [`RewardTrainer`](https://huggingface.co/docs/trl/reward_trainer):
+
+```python
+from trl import RewardTrainer
+from datasets import load_dataset
+
+dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
+
+trainer = RewardTrainer(
+    model="Qwen/Qwen2.5-0.5B-Instruct",
+    train_dataset=dataset,
+)
+trainer.train()
+```
+
+## Command Line Interface (CLI)
+
+You can use the TRL Command Line Interface (CLI) to quickly get started with post-training methods like Supervised Fine-Tuning (SFT) or Direct Preference Optimization (DPO):
+
+**SFT:**
+
+```bash
+trl sft --model_name_or_path Qwen/Qwen2.5-0.5B \
+    --dataset_name trl-lib/Capybara \
+    --output_dir Qwen2.5-0.5B-SFT
+```
+
+**DPO:**
+
+```bash
+trl dpo --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
+    --dataset_name argilla/Capybara-Preferences \
+    --output_dir Qwen2.5-0.5B-DPO 
+```
+
+Read more about CLI in the [relevant documentation section](https://huggingface.co/docs/trl/clis) or use `--help` for more details.
+
+## Development
+
+If you want to contribute to `trl` or customize it to your needs make sure to read the [contribution guide](https://github.com/huggingface/trl/blob/main/CONTRIBUTING.md) and make sure you make a dev install:
+
+```bash
+git clone https://github.com/huggingface/trl.git
+cd trl/
+pip install -e .[dev]
+```
+
+## Experimental
+
+A minimal incubation area is available under `trl.experimental` for unstable / fast-evolving features. Anything there may change or be removed in any release without notice.
+
+Example:
+
+```python
+from trl.experimental.new_trainer import NewTrainer
+```
+
+Read more in the [Experimental docs](https://huggingface.co/docs/trl/experimental_overview).
+
+## Citation
+
+```bibtex
+@software{vonwerra2020trl,
+  title   = {{TRL: Transformers Reinforcement Learning}},
+  author  = {von Werra, Leandro and Belkada, Younes and Tunstall, Lewis and Beeching, Edward and Thrush, Tristan and Lambert, Nathan and Huang, Shengyi and Rasul, Kashif and Gallouédec, Quentin},
+  license = {Apache-2.0},
+  url     = {https://github.com/huggingface/trl},
+  year    = {2020}
+}
+```
+
+## License
+
+This repository's source code is available under the [Apache-2.0 License](LICENSE).

tasks/tasksmith-0ea2241cceeb/environment/source/trl.egg-info/SOURCES.txt

@@ -0,0 +1,178 @@
+CONTRIBUTING.md
+LICENSE
+MANIFEST.in
+README.md
+VERSION
+pyproject.toml
+trl/__init__.py
+trl/_compat.py
+trl/_lazy_module.py
+trl/chat_template_utils.py
+trl/data_utils.py
+trl/import_utils.py
+trl/py.typed
+trl.egg-info/PKG-INFO
+trl.egg-info/SOURCES.txt
+trl.egg-info/dependency_links.txt
+trl.egg-info/entry_points.txt
+trl.egg-info/requires.txt
+trl.egg-info/top_level.txt
+trl/accelerate_configs/fsdp1.yaml
+trl/accelerate_configs/fsdp2.yaml
+trl/accelerate_configs/multi_gpu.yaml
+trl/accelerate_configs/single_gpu.yaml
+trl/accelerate_configs/zero1.yaml
+trl/accelerate_configs/zero2.yaml
+trl/accelerate_configs/zero3.yaml
+trl/chat_templates/README.md
+trl/chat_templates/gptoss.jinja
+trl/chat_templates/gptoss_training.jinja
+trl/chat_templates/qwen3.jinja
+trl/chat_templates/qwen3_5_2b_and_below.jinja
+trl/chat_templates/qwen3_5_4b_and_above.jinja
+trl/chat_templates/qwen3_training.jinja
+trl/cli/__init__.py
+trl/cli/accelerate_config.py
+trl/cli/accelerate_launcher.py
+trl/cli/main.py
+trl/cli/commands/__init__.py
+trl/cli/commands/base.py
+trl/cli/commands/env.py
+trl/cli/commands/skills.py
+trl/cli/commands/training.py
+trl/cli/commands/vllm_serve.py
+trl/experimental/__init__.py
+trl/experimental/merge_model_callback.py
+trl/experimental/utils.py
+trl/experimental/winrate_callback.py
+trl/experimental/async_grpo/__init__.py
+trl/experimental/async_grpo/async_grpo_config.py
+trl/experimental/async_grpo/async_grpo_trainer.py
+trl/experimental/async_grpo/async_rollout_worker.py
+trl/experimental/bco/__init__.py
+trl/experimental/bco/bco_config.py
+trl/experimental/bco/bco_trainer.py
+trl/experimental/bema_for_ref_model/__init__.py
+trl/experimental/bema_for_ref_model/callback.py
+trl/experimental/bema_for_ref_model/dpo_trainer.py
+trl/experimental/cpo/__init__.py
+trl/experimental/cpo/cpo_config.py
+trl/experimental/cpo/cpo_trainer.py
+trl/experimental/distillation/__init__.py
+trl/experimental/distillation/distillation.py
+trl/experimental/distillation/distillation_config.py
+trl/experimental/distillation/distillation_trainer.py
+trl/experimental/dppo/__init__.py
+trl/experimental/dppo/dppo_config.py
+trl/experimental/dppo/dppo_trainer.py
+trl/experimental/gfpo/__init__.py
+trl/experimental/gfpo/gfpo_config.py
+trl/experimental/gfpo/gfpo_trainer.py
+trl/experimental/gkd/__init__.py
+trl/experimental/gkd/gkd_config.py
+trl/experimental/gkd/gkd_trainer.py
+trl/experimental/gold/__init__.py
+trl/experimental/gold/gold.py
+trl/experimental/gold/gold_config.py
+trl/experimental/gold/gold_trainer.py
+trl/experimental/grpo_with_replay_buffer/__init__.py
+trl/experimental/grpo_with_replay_buffer/grpo_with_replay_buffer_config.py
+trl/experimental/grpo_with_replay_buffer/grpo_with_replay_buffer_trainer.py
+trl/experimental/gspo_token/__init__.py
+trl/experimental/gspo_token/grpo_trainer.py
+trl/experimental/judges/__init__.py
+trl/experimental/judges/judges.py
+trl/experimental/kto/__init__.py
+trl/experimental/kto/kto_config.py
+trl/experimental/kto/kto_trainer.py
+trl/experimental/minillm/__init__.py
+trl/experimental/minillm/minillm_config.py
+trl/experimental/minillm/minillm_trainer.py
+trl/experimental/nash_md/__init__.py
+trl/experimental/nash_md/nash_md_config.py
+trl/experimental/nash_md/nash_md_trainer.py
+trl/experimental/online_dpo/__init__.py
+trl/experimental/online_dpo/online_dpo_config.py
+trl/experimental/online_dpo/online_dpo_trainer.py
+trl/experimental/openenv/__init__.py
+trl/experimental/openenv/utils.py
+trl/experimental/orpo/__init__.py
+trl/experimental/orpo/orpo_config.py
+trl/experimental/orpo/orpo_trainer.py
+trl/experimental/papo/__init__.py
+trl/experimental/papo/papo_config.py
+trl/experimental/papo/papo_trainer.py
+trl/experimental/ppo/__init__.py
+trl/experimental/ppo/modeling_value_head.py
+trl/experimental/ppo/ppo_config.py
+trl/experimental/ppo/ppo_trainer.py
+trl/experimental/prm/__init__.py
+trl/experimental/prm/prm_config.py
+trl/experimental/prm/prm_trainer.py
+trl/experimental/sdft/__init__.py
+trl/experimental/sdft/sdft.py
+trl/experimental/sdft/sdft_config.py
+trl/experimental/sdft/sdft_trainer.py
+trl/experimental/sdpo/__init__.py
+trl/experimental/sdpo/sdpo.py
+trl/experimental/sdpo/sdpo_config.py
+trl/experimental/sdpo/sdpo_trainer.py
+trl/experimental/self_distillation/__init__.py
+trl/experimental/self_distillation/base_self_distillation_trainer.py
+trl/experimental/self_distillation/online_rollout_mixin.py
+trl/experimental/self_distillation/peft_adapter_ema_callback.py
+trl/experimental/self_distillation/self_distillation_config.py
+trl/experimental/self_distillation/self_distillation_mixin.py
+trl/experimental/self_distillation/teacher_context.py
+trl/experimental/xpo/__init__.py
+trl/experimental/xpo/xpo_config.py
+trl/experimental/xpo/xpo_trainer.py
+trl/extras/__init__.py
+trl/extras/dataset_formatting.py
+trl/extras/profiling.py
+trl/generation/__init__.py
+trl/generation/vllm_client.py
+trl/generation/vllm_generation.py
+trl/models/__init__.py
+trl/models/activation_offloading.py
+trl/models/utils.py
+trl/rewards/__init__.py
+trl/rewards/accuracy_rewards.py
+trl/rewards/format_rewards.py
+trl/rewards/other_rewards.py
+trl/scripts/__init__.py
+trl/scripts/_hf_argparser.py
+trl/scripts/dpo.py
+trl/scripts/env.py
+trl/scripts/grpo.py
+trl/scripts/kto.py
+trl/scripts/reward.py
+trl/scripts/rloo.py
+trl/scripts/sft.py
+trl/scripts/utils.py
+trl/scripts/vllm_serve.py
+trl/skills/__init__.py
+trl/skills/cli.py
+trl/skills/skills.py
+trl/skills/trl-training/SKILL.md
+trl/templates/completions_dataset_card.md
+trl/templates/lm_model_card.md
+trl/templates/rm_model_card.md
+trl/trainer/__init__.py
+trl/trainer/base_config.py
+trl/trainer/base_trainer.py
+trl/trainer/callbacks.py
+trl/trainer/dpo_config.py
+trl/trainer/dpo_trainer.py
+trl/trainer/grpo_config.py
+trl/trainer/grpo_trainer.py
+trl/trainer/kto_config.py
+trl/trainer/kto_trainer.py
+trl/trainer/model_config.py
+trl/trainer/reward_config.py
+trl/trainer/reward_trainer.py
+trl/trainer/rloo_config.py
+trl/trainer/rloo_trainer.py
+trl/trainer/sft_config.py
+trl/trainer/sft_trainer.py
+trl/trainer/utils.py

tasks/tasksmith-0ea2241cceeb/environment/source/trl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tasks/tasksmith-0ea2241cceeb/environment/source/trl.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trl = trl.cli:main

tasks/tasksmith-0ea2241cceeb/environment/source/trl.egg-info/requires.txt

@@ -0,0 +1,82 @@
+accelerate>=1.4.0
+datasets>=4.7.0
+jinja2
+packaging>20.0
+transformers>=4.56.2
+
+[bco]
+scikit-learn
+joblib
+
+[deepspeed]
+deepspeed>=0.14.4
+transformers!=5.1.0
+
+[dev]
+scikit-learn
+joblib
+deepspeed>=0.14.4
+openai>=1.23.2
+llm-blender>=0.0.2
+kernels
+liger-kernel>=0.7.0
+peft>=0.8.0
+pre-commit
+hf-doc-builder
+bitsandbytes
+pytest-cov
+pytest-datadir>=1.7.0
+pytest-rerunfailures==15.1
+pytest-xdist
+pytest
+Pillow
+torchvision
+num2words==0.5.14
+jmespath
+
+[judges]
+openai>=1.23.2
+llm-blender>=0.0.2
+transformers<5.0.0
+
+[kernels]
+kernels
+
+[liger]
+liger-kernel>=0.7.0
+
+[math_verify]
+math-verify>=0.5.2
+
+[peft]
+peft>=0.8.0
+
+[quality]
+pre-commit
+hf-doc-builder
+
+[quantization]
+bitsandbytes
+
+[scikit]
+scikit-learn
+
+[test]
+pytest-cov
+pytest-datadir>=1.7.0
+pytest-rerunfailures==15.1
+pytest-xdist
+pytest
+
+[vllm]
+vllm<=0.17.1,>=0.11.0
+fastapi
+pydantic
+aiohttp>=3.13.3
+requests
+uvicorn
+
+[vlm]
+Pillow
+torchvision
+num2words==0.5.14

tasks/tasksmith-0ea2241cceeb/environment/source/trl.egg-info/top_level.txt

@@ -0,0 +1 @@
+trl

tasks/tasksmith-0ea2241cceeb/environment/source/trl/__init__.py

@@ -0,0 +1,132 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from typing import TYPE_CHECKING
+
+from . import _compat
+from ._lazy_module import _LazyModule
+
+
+try:
+    __version__ = version("trl")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+_import_structure = {
+    "chat_template_utils": [
+        "add_response_schema",
+        "clone_chat_template",
+        "get_training_chat_template",
+        "supports_tool_calling",
+    ],
+    "data_utils": [
+        "apply_chat_template",
+        "extract_prompt",
+        "is_conversational",
+        "is_conversational_from_value",
+        "maybe_apply_chat_template",
+        "maybe_convert_to_chatml",
+        "maybe_extract_prompt",
+        "maybe_unpair_preference_dataset",
+        "pack_dataset",
+        "prepare_multimodal_messages",
+        "prepare_multimodal_messages_vllm",
+        "unpair_preference_dataset",
+    ],
+    "models": ["create_reference_model"],
+    "scripts": ["DatasetMixtureConfig", "ScriptArguments", "TrlParser", "get_dataset", "init_zero_verbose"],
+    "trainer": [
+        "BEMACallback",
+        "DPOConfig",
+        "DPOTrainer",
+        "GRPOConfig",
+        "GRPOTrainer",
+        "KTOConfig",
+        "KTOTrainer",
+        "LogCompletionsCallback",
+        "ModelConfig",
+        "RewardConfig",
+        "RewardTrainer",
+        "RichProgressCallback",
+        "RLOOConfig",
+        "RLOOTrainer",
+        "SFTConfig",
+        "SFTTrainer",
+        "SyncRefModelCallback",
+        "WeaveCallback",
+        "get_kbit_device_map",
+        "get_peft_config",
+        "get_quantization_config",
+    ],
+}
+
+if TYPE_CHECKING:
+    from .chat_template_utils import (
+        add_response_schema,
+        clone_chat_template,
+        get_training_chat_template,
+        supports_tool_calling,
+    )
+    from .data_utils import (
+        apply_chat_template,
+        extract_prompt,
+        is_conversational,
+        is_conversational_from_value,
+        maybe_apply_chat_template,
+        maybe_convert_to_chatml,
+        maybe_extract_prompt,
+        maybe_unpair_preference_dataset,
+        pack_dataset,
+        prepare_multimodal_messages,
+        prepare_multimodal_messages_vllm,
+        unpair_preference_dataset,
+    )
+    from .models import create_reference_model
+    from .scripts import DatasetMixtureConfig, ScriptArguments, TrlParser, get_dataset, init_zero_verbose
+    from .trainer import (
+        BEMACallback,
+        DPOConfig,
+        DPOTrainer,
+        GRPOConfig,
+        GRPOTrainer,
+        KTOConfig,
+        KTOTrainer,
+        LogCompletionsCallback,
+        ModelConfig,
+        RewardConfig,
+        RewardTrainer,
+        RichProgressCallback,
+        RLOOConfig,
+        RLOOTrainer,
+        SFTConfig,
+        SFTTrainer,
+        SyncRefModelCallback,
+        WeaveCallback,
+        get_kbit_device_map,
+        get_peft_config,
+        get_quantization_config,
+    )
+
+else:
+    import sys
+
+    sys.modules[__name__] = _LazyModule(
+        __name__,
+        globals()["__file__"],
+        _import_structure,
+        module_spec=__spec__,
+        extra_objects={"__version__": __version__},
+    )

tasks/tasksmith-0ea2241cceeb/environment/source/trl/_compat.py

@@ -0,0 +1,250 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Compatibility shims for third-party dependencies.
+
+This module contains temporary patches to handle version incompatibilities between TRL's dependencies.
+
+Each patch should be removed when minimum version requirements eliminate the need.
+"""
+
+import warnings
+
+from packaging.version import Version
+
+from .import_utils import _is_package_available
+
+
+def _is_package_version_below(package_name: str, version_threshold: str) -> bool:
+    """
+    Check if installed package version is below the given threshold.
+
+    Args:
+        package_name (str): Package name.
+        version_threshold (str): Maximum version threshold.
+
+    Returns:
+        - True if package is installed and version < version_threshold.
+        - False if package is not installed or version >= version_threshold.
+    """
+    try:
+        is_available, version = _is_package_available(package_name, return_version=True)
+        return is_available and Version(version) < Version(version_threshold)
+    except Exception as e:
+        warnings.warn(
+            f"Failed to check {package_name} version against {version_threshold}: {e}. "
+            f"Compatibility patch may not be applied.",
+            stacklevel=2,
+        )
+        return False
+
+
+def _is_package_version_at_least(package_name: str, version_threshold: str) -> bool:
+    """
+    Check if installed package version is at least the given threshold.
+
+    Args:
+        package_name (str): Package name.
+        version_threshold (str): Minimum version threshold.
+
+    Returns:
+        - True if package is installed and version >= version_threshold.
+        - False if package is not installed or version < version_threshold.
+    """
+    try:
+        is_available, version = _is_package_available(package_name, return_version=True)
+        return is_available and Version(version) >= Version(version_threshold)
+    except Exception as e:
+        warnings.warn(
+            f"Failed to check {package_name} version against {version_threshold}: {e}. "
+            f"Compatibility patch may not be applied.",
+            stacklevel=2,
+        )
+        return False
+
+
+def _patch_vllm_logging() -> None:
+    """Set vLLM logging level to ERROR by default to reduce noise."""
+    if _is_package_available("vllm"):
+        import os
+
+        os.environ["VLLM_LOGGING_LEVEL"] = os.getenv("VLLM_LOGGING_LEVEL", "ERROR")
+
+
+def _patch_vllm_disabled_tqdm() -> None:
+    """
+    Fix DisabledTqdm class in vLLM.
+
+    - Bug introduced in https://github.com/vllm-project/vllm/pull/52
+    - Fixed in https://github.com/vllm-project/vllm/pull/28471 (released in v0.11.1)
+    - Since TRL currently supports vLLM v0.11.0-0.17.1, we patch it here
+    - This can be removed when TRL requires vLLM>=0.11.1
+    """
+    if _is_package_version_below("vllm", "0.11.1"):
+        try:
+            import vllm.model_executor.model_loader.weight_utils
+            from tqdm import tqdm
+
+            class DisabledTqdm(tqdm):
+                def __init__(self, *args, **kwargs):
+                    kwargs["disable"] = True
+                    super().__init__(*args, **kwargs)
+
+            vllm.model_executor.model_loader.weight_utils.DisabledTqdm = DisabledTqdm
+        except (ImportError, AttributeError) as e:
+            warnings.warn(f"Failed to patch vLLM DisabledTqdm: {e}", stacklevel=2)
+
+
+def _patch_vllm_cached_tokenizer() -> None:
+    """
+    Fix get_cached_tokenizer for transformers v5 compatibility.
+
+    - Issue: vLLM's get_cached_tokenizer accesses all_special_tokens_extended
+    - Removed in transformers: https://github.com/huggingface/transformers/pull/40936 (transformers>=5.0.0)
+    - Fixed in https://github.com/vllm-project/vllm/pull/29686 (released in v0.12.0)
+    - This can be removed when TRL requires vLLM>=0.12.0
+    """
+    if _is_package_version_at_least("transformers", "5.0.0") and _is_package_version_below("vllm", "0.12.0"):
+        try:
+            import contextlib
+            import copy
+
+            import vllm.transformers_utils.tokenizer
+
+            def get_cached_tokenizer(tokenizer):
+                cached_tokenizer = copy.copy(tokenizer)
+                tokenizer_all_special_ids = tokenizer.all_special_ids
+                tokenizer_all_special_tokens = tokenizer.all_special_tokens
+                tokenizer_vocab = tokenizer.get_vocab()
+                tokenizer_len = len(tokenizer)
+
+                max_token_id = max(tokenizer_vocab.values())
+                if hasattr(tokenizer, "vocab_size"):
+                    with contextlib.suppress(NotImplementedError):
+                        max_token_id = max(max_token_id, tokenizer.vocab_size)
+
+                class CachedTokenizer(tokenizer.__class__):  # type: ignore
+                    @property
+                    def all_special_ids(self) -> list[int]:
+                        return tokenizer_all_special_ids
+
+                    @property
+                    def all_special_tokens(self) -> list[str]:
+                        return tokenizer_all_special_tokens
+
+                    @property
+                    def max_token_id(self) -> int:
+                        return max_token_id
+
+                    def get_vocab(self) -> dict[str, int]:
+                        return tokenizer_vocab
+
+                    def __len__(self) -> int:
+                        return tokenizer_len
+
+                    def __reduce__(self):
+                        return get_cached_tokenizer, (tokenizer,)
+
+                CachedTokenizer.__name__ = f"Cached{tokenizer.__class__.__name__}"
+
+                cached_tokenizer.__class__ = CachedTokenizer
+                return cached_tokenizer
+
+            vllm.transformers_utils.tokenizer.get_cached_tokenizer = get_cached_tokenizer
+        except (ImportError, AttributeError) as e:
+            warnings.warn(f"Failed to patch vLLM cached_tokenizer: {e}", stacklevel=2)
+
+
+def _patch_transformers_hybrid_cache() -> None:
+    """
+    Fix HybridCache import for transformers v5 compatibility.
+
+    - Issue: peft import HybridCache from transformers.cache_utils
+    - HybridCache removed in https://github.com/huggingface/transformers/pull/43168 (transformers>=5.0.0)
+    - Fixed in peft: https://github.com/huggingface/peft/pull/2735 (released in v0.18.0)
+    - This can be removed when TRL requires peft>=0.18.0
+    """
+    if _is_package_version_at_least("transformers", "5.0.0") and _is_package_version_below("peft", "0.18.0"):
+        try:
+            import transformers.cache_utils
+            from transformers.utils.import_utils import _LazyModule
+
+            Cache = transformers.cache_utils.Cache
+
+            # Patch for liger_kernel: Add HybridCache as an alias for Cache in the cache_utils module
+            transformers.cache_utils.HybridCache = Cache
+
+            # Patch for peft: Patch _LazyModule.__init__ to add HybridCache to transformers' lazy loading structures
+            _original_lazy_module_init = _LazyModule.__init__
+
+            def _patched_lazy_module_init(self, name, *args, **kwargs):
+                _original_lazy_module_init(self, name, *args, **kwargs)
+                if name == "transformers":
+                    # Update _LazyModule's internal structures
+                    if hasattr(self, "_import_structure") and "cache_utils" in self._import_structure:
+                        if "HybridCache" not in self._import_structure["cache_utils"]:
+                            self._import_structure["cache_utils"].append("HybridCache")
+
+                    if hasattr(self, "_class_to_module"):
+                        self._class_to_module["HybridCache"] = "cache_utils"
+
+                    if hasattr(self, "__all__") and "HybridCache" not in self.__all__:
+                        self.__all__.append("HybridCache")
+
+                    self.HybridCache = Cache
+
+            _LazyModule.__init__ = _patched_lazy_module_init
+
+        except Exception as e:
+            warnings.warn(f"Failed to patch transformers HybridCache compatibility: {e}", stacklevel=2)
+
+
+def _patch_transformers_parallelism_config() -> None:
+    """
+    Fix ParallelismConfig for transformers compatibility.
+
+    Ensure that ``transformers.training_args`` always defines the symbol `ParallelismConfig` so that Python's
+    `typing.get_type_hints` can resolve annotations on `transformers.TrainingArguments` without raising a `NameError`.
+
+    This is needed when running with ``accelerate<1.10.1``, where the module ``accelerate.parallelism_config`` did not
+    exist and therefore the type alias is not imported by Transformers.
+
+    See upstream fix PR in transformers#40818.
+
+    - Issue: transformers imports ParallelismConfig only if accelerate>=1.10.1 and raises NameError if
+      accelerate<1.10.1
+    - Fixed in transformers: https://github.com/huggingface/transformers/pull/40818 (released in v4.57.0)
+    - This can be removed when TRL requires transformers>=4.57.0 or accelerate>=1.10.1
+    """
+    if _is_package_version_below("transformers", "4.57.0") and _is_package_version_below("accelerate", "1.10.1"):
+        try:
+            from typing import Any
+
+            import transformers.training_args
+
+            if not hasattr(transformers.training_args, "ParallelismConfig"):
+                transformers.training_args.ParallelismConfig = Any
+        except Exception as e:
+            warnings.warn(f"Failed to patch transformers ParallelismConfig compatibility: {e}", stacklevel=2)
+
+
+# Apply vLLM patches
+_patch_vllm_logging()
+_patch_vllm_disabled_tqdm()
+_patch_vllm_cached_tokenizer()
+
+# Apply transformers patches
+_patch_transformers_hybrid_cache()
+_patch_transformers_parallelism_config()  # before creating HfArgumentParser

tasks/tasksmith-0ea2241cceeb/environment/source/trl/_lazy_module.py

@@ -0,0 +1,79 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+import os
+from itertools import chain
+from types import ModuleType
+from typing import Any
+
+
+class _LazyModule(ModuleType):
+    """
+    Module class that surfaces all objects but only performs associated imports when the objects are requested.
+    """
+
+    # Very heavily inspired by optuna.integration._IntegrationModule
+    # https://github.com/optuna/optuna/blob/master/optuna/integration/__init__.py
+    def __init__(self, name, module_file, import_structure, module_spec=None, extra_objects=None):
+        super().__init__(name)
+        self._modules = set(import_structure.keys())
+        self._class_to_module = {}
+        for key, values in import_structure.items():
+            for value in values:
+                self._class_to_module[value] = key
+        # Needed for autocompletion in an IDE
+        self.__all__ = list(import_structure.keys()) + list(chain(*import_structure.values()))
+        self.__file__ = module_file
+        self.__spec__ = module_spec
+        self.__path__ = [os.path.dirname(module_file)]
+        self._objects = {} if extra_objects is None else extra_objects
+        self._name = name
+        self._import_structure = import_structure
+
+    # Needed for autocompletion in an IDE
+    def __dir__(self):
+        result = super().__dir__()
+        # The elements of self.__all__ that are submodules may or may not be in the dir already, depending on whether
+        # they have been accessed or not. So we only add the elements of self.__all__ that are not already in the dir.
+        for attr in self.__all__:
+            if attr not in result:
+                result.append(attr)
+        return result
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self._objects:
+            return self._objects[name]
+        if name in self._modules:
+            value = self._get_module(name)
+        elif name in self._class_to_module.keys():
+            module = self._get_module(self._class_to_module[name])
+            value = getattr(module, name)
+        else:
+            raise AttributeError(f"module {self.__name__} has no attribute {name}")
+
+        setattr(self, name, value)
+        return value
+
+    def _get_module(self, module_name: str):
+        try:
+            return importlib.import_module("." + module_name, self.__name__)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to import {self.__name__}.{module_name} because of the following error (look up to see its"
+                f" traceback):\n{e}"
+            ) from e
+
+    def __reduce__(self):
+        return (self.__class__, (self._name, self.__file__, self._import_structure))

tasks/tasksmith-0ea2241cceeb/environment/source/trl/accelerate_configs/fsdp1.yaml

@@ -0,0 +1,28 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+enable_cpu_affinity: false
+fsdp_config:
+  fsdp_activation_checkpointing: false
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_backward_prefetch: BACKWARD_PRE
+  fsdp_cpu_ram_efficient_loading: true
+  fsdp_forward_prefetch: true
+  fsdp_offload_params: false
+  fsdp_reshard_after_forward: FULL_SHARD
+  fsdp_state_dict_type: FULL_STATE_DICT
+  fsdp_sync_module_states: true
+  fsdp_use_orig_params: true
+  fsdp_version: 1
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

tasks/tasksmith-0ea2241cceeb/environment/source/trl/accelerate_configs/fsdp2.yaml

@@ -0,0 +1,25 @@
+# Requires accelerate 1.7.0 or higher
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+enable_cpu_affinity: false
+fsdp_config:
+  fsdp_activation_checkpointing: false
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_cpu_ram_efficient_loading: true
+  fsdp_offload_params: false
+  fsdp_reshard_after_forward: true
+  fsdp_state_dict_type: FULL_STATE_DICT
+  fsdp_version: 2
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

tasks/tasksmith-0ea2241cceeb/environment/source/trl/accelerate_configs/multi_gpu.yaml

@@ -0,0 +1,16 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: MULTI_GPU
+downcast_bf16: 'no'
+gpu_ids: all
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'bf16'
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

tasks/tasksmith-0ea2241cceeb/environment/source/trl/accelerate_configs/single_gpu.yaml

@@ -0,0 +1,16 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: "NO"
+downcast_bf16: 'no'
+gpu_ids: all
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'bf16'
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

tasks/tasksmith-0ea2241cceeb/environment/source/trl/accelerate_configs/zero1.yaml

@@ -0,0 +1,20 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  gradient_accumulation_steps: 1
+  zero3_init_flag: false
+  zero_stage: 1
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'bf16'
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

tasks/tasksmith-0ea2241cceeb/environment/source/trl/accelerate_configs/zero2.yaml

@@ -0,0 +1,21 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: false
+  zero_stage: 2
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'bf16'
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

tasks/tasksmith-0ea2241cceeb/environment/source/trl/accelerate_configs/zero3.yaml

@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

tasks/tasksmith-0ea2241cceeb/environment/source/trl/chat_template_utils.py

@@ -0,0 +1,532 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+
+from jinja2 import TemplateError
+from transformers import AddedToken, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, ProcessorMixin
+
+from .data_utils import prepare_multimodal_messages
+
+
+_CHAT_TEMPLATES_DIR = Path(__file__).parent / "chat_templates"
+
+
+def clone_chat_template(
+    model: PreTrainedModel,
+    tokenizer: PreTrainedTokenizer,
+    source_tokenizer_path: str,
+    resize_to_multiple_of: int | None = 64,
+) -> tuple[PreTrainedModel, PreTrainedTokenizer, list[int]]:
+    """
+    Clones a chat template from a source tokenizer to the target tokenizer and updates the model accordingly.
+
+    This function:
+    - Copies the chat template from a source tokenizer to the target tokenizer.
+    - Adds any new tokens from the source tokenizer to the target tokenizer.
+    - Sets and synchronizes the EOS token across the tokenizer and model.
+    - Resizes the model's token embeddings to match the new vocabulary size, optionally rounding it up to a multiple of
+      a specified value. In such cases, dummy tokens are added to the tokenizer to ensure the vocabulary size matches
+      the embedding dimensions.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]):
+            Model to update.
+        tokenizer ([`~transformers.PreTrainedTokenizer`]):
+            Tokenizer to update.
+        source_tokenizer_path (`str`):
+            Path or identifier of the pretrained tokenizer to clone from.
+        resize_to_multiple_of (`int` or `None`, *optional*, defaults to `64`):
+            The embedding layer will be resized to the new vocabulary size. If this is not `None`, it will round up the
+            new vocabulary size to the nearest multiple of this value.
+
+    Returns:
+        model ([`~transformers.PreTrainedModel`]):
+            Updated model with resized token embeddings and EOS token configured.
+        tokenizer ([`~transformers.PreTrainedTokenizer`]):
+            Updated tokenizer with the chat template and special tokens applied.
+        added_tokens (`list[int]`):
+            List of tokens that were added to the tokenizer from the source tokenizer.
+
+    Example:
+    ```python
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    from trl import clone_chat_template
+
+    model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")
+    tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B")
+    model, tokenizer, added_tokens = clone_chat_template(model, tokenizer, "Qwen/Qwen3-0.6B")
+    ```
+    """
+    # Load the source tokenizer containing the desired chat template
+    tokenizer_source = AutoTokenizer.from_pretrained(source_tokenizer_path)
+
+    # Copy the chat template from the source tokenizer
+    tokenizer.chat_template = tokenizer_source.get_chat_template()
+
+    # Ensure all added tokens from the source are available in the target tokenizer
+    added_tokens = [
+        token for token in tokenizer_source.added_tokens_decoder.values() if token.content not in tokenizer.vocab
+    ]
+    tokenizer.add_tokens(added_tokens)
+
+    # Set the EOS token from the source tokenizer (important for generation)
+    tokenizer.eos_token = tokenizer_source.eos_token
+    model.config.eos_token_id = tokenizer.eos_token_id
+    if model.can_generate():  # Non-generative models (e.g. SequenceClassification) may not have a generation_config
+        model.generation_config.eos_token_id = tokenizer.eos_token_id
+
+    # Resize model embeddings to include any new tokens, optionally rounding up to a multiple
+    model.resize_token_embeddings(
+        # After studying many tokenizers, we found that len(tokenizer.vocab) is the most reliable way to get the vocab
+        # size. Avoid using tokenizer.vocab_size or tokenizer.vocab_size + len(tokenizer.added_tokens_encoder),
+        # as handling of special and added tokens varies across tokenizers.
+        new_num_tokens=len(tokenizer.vocab),
+        pad_to_multiple_of=resize_to_multiple_of if resize_to_multiple_of is not None else None,
+    )
+
+    # After resizing, the embedding matrix size may exceed the vocabulary size. Add dummy tokens to the tokenizer to
+    # ensure vocabulary size matches the embedding matrix dimensions.
+    idx = 0
+    while model.vocab_size > len(tokenizer.vocab):
+        dummy_token = AddedToken(f"<extra_id_{idx}>")
+        is_added = tokenizer.add_tokens(dummy_token)
+        idx += 1
+        if is_added == 1:
+            added_tokens.append(dummy_token)
+
+    # Verify that vocabulary size now matches embedding dimensions
+    if len(tokenizer.vocab) != model.vocab_size:
+        raise RuntimeError(
+            f"Vocabulary size mismatch after resizing: tokenizer vocab size is {len(tokenizer.vocab)}, but model "
+            f"embedding size is {model.vocab_size}. This indicates an internal error in the token alignment process."
+        )
+    added_tokens = [token.content for token in added_tokens]
+    added_tokens = tokenizer.convert_tokens_to_ids(added_tokens)
+    return model, tokenizer, added_tokens
+
+
+gptoss_schema = {
+    # Normalize final content to analysis format so both map to the same "content" group.
+    "x-regex-substitutions": [
+        [r"<\|channel\|>final<\|message\|>(.*?)<\|return\|>", r"<|channel|>analysis<|message|>\1<|end|>"],
+    ],
+    "x-regex": r"^(?:<\|channel\|>analysis<\|message\|>(?P<content>.*?)<\|end\|>(?:<\|start\|>assistant)?)?\s*(?P<tool_calls>to=functions\.\S+<\|channel\|>commentary json<\|message\|>.*?<\|call\|>)?$",
+    "type": "object",
+    "properties": {
+        "role": {"const": "assistant"},
+        "content": {"type": "string"},
+        "tool_calls": {
+            "type": "array",
+            "x-regex-iterator": r"(to=functions\.\S+<\|channel\|>commentary json<\|message\|>.*?<\|call\|>)",
+            "items": {
+                # Convert "to=functions.NAME<|channel|>commentary json<|message|>ARGS<|call|>"
+                # into '{"name": "NAME", "arguments": ARGS}' so it can be parsed as JSON.
+                "x-regex-substitutions": [
+                    [
+                        r"to=functions\.(\S+)<\|channel\|>commentary json<\|message\|>(.*?)<\|call\|>",
+                        r'{"name": "\1", "arguments": \2}',
+                    ],
+                ],
+                "x-parser": "json",
+                "x-parser-args": {"transform": "{type: 'function', function: @}"},
+                "type": "object",
+                "properties": {
+                    "type": {"const": "function"},
+                    "function": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                            "arguments": {
+                                "type": "object",
+                                "additionalProperties": {},
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+}
+
+# Adapted and corrected versions of the schemas from:
+# https://github.com/huggingface/transformers/blob/main/tests/utils/test_chat_parsing_utils.py
+qwen3_schema = {
+    "x-regex": r"^(?:<think>\n?(?:(?P<reasoning_content>.*?\S.*?)\n?|[\s]*)</think>\s*)?(?P<content>.*?)(?:\n(?=<tool_call>))?(?=(?:<tool_call>|<\|im_end\|>|$))(?P<tool_calls>(?:<tool_call>.+?</tool_call>\s*)+)?\s*(?:<\|im_end\|>|$)",
+    "type": "object",
+    "properties": {
+        "role": {"const": "assistant"},
+        "content": {"type": "string"},
+        "reasoning_content": {"type": "string"},
+        "tool_calls": {
+            "type": "array",
+            "x-regex-iterator": r"<tool_call>\s*(.+?)\s*</tool_call>",
+            "items": {
+                "x-parser": "json",
+                "x-parser-args": {"transform": "{type: 'function', function: @}"},
+                "type": "object",
+                "properties": {
+                    "type": {"const": "function"},
+                    "function": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                            "arguments": {
+                                "type": "object",
+                                "additionalProperties": {},
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+}
+
+qwen3_5_schema = {
+    "x-regex": r"^(?:(?:<think>\n?)?(?:(?P<reasoning_content>.*?\S.*?)\n?|[\s]*)</think>\s*)?(?P<content>.*?)(?:\n+(?=<tool_call>))?(?=(?:<tool_call>|<\|im_end\|>|$))(?P<tool_calls>(?:<tool_call>.+?</tool_call>\s*)+)?\s*(?:<\|im_end\|>|$)",
+    "type": "object",
+    "properties": {
+        "role": {"const": "assistant"},
+        "content": {"type": "string"},
+        "reasoning_content": {"type": "string"},
+        "tool_calls": {
+            "type": "array",
+            "x-regex-iterator": r"<tool_call>\s*(.+?)\s*</tool_call>",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "type": {"const": "function"},
+                    "function": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string", "x-regex": r"<function=([^\n>]+)>"},
+                            "arguments": {
+                                "type": "object",
+                                "x-regex-key-value": r"<parameter=(?P<key>[^>\n]+)>\n(?P<value>.*?)\n</parameter>",
+                                "default": {},
+                                "additionalProperties": {
+                                    "x-parser": "json",
+                                    "x-parser-args": {"allow_non_json": True},
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+}
+
+
+gptoss_chat_template = (_CHAT_TEMPLATES_DIR / "gptoss.jinja").read_text()
+
+qwen3_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3.jinja").read_text()
+
+qwen3_5_chat_template_2b_and_below = (_CHAT_TEMPLATES_DIR / "qwen3_5_2b_and_below.jinja").read_text()
+
+qwen3_5_chat_template_4b_and_above = (_CHAT_TEMPLATES_DIR / "qwen3_5_4b_and_above.jinja").read_text()
+
+
+def add_response_schema(tokenizer: PreTrainedTokenizer) -> PreTrainedTokenizer:
+    r"""
+    Adds the appropriate response schema to the given tokenizer based on its chat template.
+
+    At the time of initial implementation, most tokenizers do not have built-in support for response schemas. While
+    waiting for broader adoption, we provide this utility function to manually set the response schema for known chat
+    templates.
+
+    Args:
+        tokenizer (`PreTrainedTokenizer`):
+            Tokenizer to which the response schema will be added.
+
+    Returns:
+        `PreTrainedTokenizer`:
+            Tokenizer with the added response schema.
+
+    Examples:
+
+    ```python
+    >>> from trl.chat_template_utils import add_response_schema
+    >>> from transformers import AutoTokenizer
+
+    >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
+    >>> tokenizer = add_response_schema(tokenizer)
+    >>> assistant_text = '<tool_call>\n{"name": "multiply", "arguments": {"a": 3, "b": 4}}\n</tool_call><|im_end|>'
+    >>> tokenizer.parse_response(assistant_text)
+    {'role': 'assistant', 'content': '', 'tool_calls': [{'type': 'function', 'function': {'name': 'multiply', 'arguments': {'a': 3, 'b': 4}}}]}
+    ```
+    """
+    if tokenizer.chat_template == gptoss_chat_template:
+        tokenizer.response_schema = gptoss_schema
+        return tokenizer
+    if tokenizer.chat_template == qwen3_chat_template:
+        tokenizer.response_schema = qwen3_schema
+        return tokenizer
+    if tokenizer.chat_template in [qwen3_5_chat_template_2b_and_below, qwen3_5_chat_template_4b_and_above]:
+        tokenizer.response_schema = qwen3_5_schema
+        return tokenizer
+    raise ValueError(
+        "Unrecognized chat template, failed to add response schema. Please manually set the response schema on the "
+        "tokenizer or processor. See the Transformers "
+        "[docs](https://huggingface.co/docs/transformers/main/en/chat_response_parsing#response-parsing) for more "
+        "details on response parsing."
+    )
+
+
+def supports_tool_calling(processing_class) -> bool:
+    """
+    Check if the processing class's chat template can render a full tool-calling conversation.
+
+    This tests two things: (1) the template doesn't error when rendering a conversation with ``user → assistant (with
+    tool_calls) → tool`` roles, and (2) the tool message content actually appears in the rendered output (some
+    templates silently swallow tool messages).
+
+    For VLMs (processors), the messages are converted to multimodal format via
+    [`~trl.data_utils.prepare_multimodal_messages`] before rendering.
+
+    Args:
+        processing_class (`PreTrainedTokenizer` or `ProcessorMixin`):
+            Tokenizer or processor instance to check.
+
+    Returns:
+        `bool`:
+            `True` if the chat template supports tool-calling conversations, `False` otherwise.
+    """
+    if processing_class.chat_template is None:
+        return False
+
+    is_vlm = isinstance(processing_class, ProcessorMixin)
+    _sentinel = "TOOL_CONTENT_c4f9a8e2"
+    tool_calls = [{"type": "function", "function": {"name": "test", "arguments": {}}}]
+    messages = [
+        {"role": "user", "content": "hi"},
+        {"role": "assistant", "content": "", "tool_calls": tool_calls},
+        {"role": "tool", "name": "test", "content": _sentinel},
+    ]
+    # VLMs expect content as [{"type": "text", "text": "..."}] instead of plain strings
+    if is_vlm:
+        messages = prepare_multimodal_messages(messages)
+
+    try:
+        rendered = processing_class.apply_chat_template(messages, tokenize=False)
+    except TemplateError:
+        # TemplateError: template rejects the role sequence (Cohere, FalconMamba, Gemma, Gemma2, Gemma3)
+        # UndefinedError (subclass): template indexes into content as a list for all roles, including tool
+        #   (Idefics2, Idefics3, LlavaNext, SmolVLM)
+        return False
+    # Some templates (e.g. Cohere2, Phi3) accept tool messages without error but silently ignore them.
+    # Check that the tool content actually appears in the rendered output.
+    return _sentinel in rendered
+
+
+def is_chat_template_prefix_preserving(tokenizer: PreTrainedTokenizer) -> bool:
+    """
+    Check whether the chat template preserves prefixes when applied.
+
+    A prefix-preserving chat template renders earlier messages identically regardless of what messages follow. This
+    property is required by `_get_tool_suffix_ids`, which extracts tool response formatting tokens by comparing
+    tokenizations with and without tool messages appended.
+
+    Args:
+        tokenizer (`PreTrainedTokenizer`):
+            Tokenizer instance to check.
+
+    Returns:
+        `bool`:
+            `True` if the chat template preserves prefixes, `False` otherwise.
+    """
+    # Use the same dummy messages as _get_tool_suffix_ids to test the exact property it relies on.
+    dummy_tool_calls = [{"type": "function", "function": {"name": "dummy", "arguments": {}}}]
+    messages1 = [
+        {"role": "user", "content": "dummy"},
+        {"role": "assistant", "content": "", "tool_calls": dummy_tool_calls},
+    ]
+    messages2 = [
+        {"role": "user", "content": "dummy"},
+        {"role": "assistant", "content": "", "tool_calls": dummy_tool_calls},
+        {"role": "tool", "name": "dummy", "content": "dummy"},
+    ]
+
+    text1 = tokenizer.apply_chat_template(messages1, tokenize=False)
+    text2 = tokenizer.apply_chat_template(messages2, tokenize=False, add_generation_prompt=True)
+
+    return text2.startswith(text1)
+
+
+qwen3_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_training.jinja").read_text()
+gptoss_training_chat_template = (_CHAT_TEMPLATES_DIR / "gptoss_training.jinja").read_text()
+
+
+def get_training_chat_template(tokenizer: PreTrainedTokenizer) -> str | None:
+    r"""
+    Get a training-compatible chat template, if needed.
+
+    Returns a patched chat template that is prefix-preserving and includes `{%% generation %%}` / `{%% endgeneration
+    %%}` markers for assistant-only loss masking. Returns `None` if the tokenizer's template already satisfies both
+    requirements. Currently supported:
+        - Qwen3
+        - GPT-OSS
+
+    Args:
+        tokenizer (`PreTrainedTokenizer`):
+            Tokenizer instance to check.
+
+    Returns:
+        `str` or `None`:
+            Training-compatible chat template, or `None` if no patching is needed.
+
+    Example:
+
+    ```python
+    >>> from trl.chat_template_utils import get_training_chat_template
+    >>> from transformers import AutoTokenizer
+
+    >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
+    >>> messages1 = [
+    ...     {"role": "user", "content": "What is 2 * 3?"},
+    ...     {
+    ...         "role": "assistant",
+    ...         "content": "",
+    ...         "tool_calls": [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 2, "b": 3}}}],
+    ...     },
+    ... ]
+    >>> messages2 = messages1 + [
+    ...     {"role": "tool", "name": "multiply", "content": "6"},
+    ... ]
+    >>> tokenizer.apply_chat_template(messages1, tokenize=False)
+    '<|im_start|>user\nWhat is 2 * 3?<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n{"name": "multiply", "arguments": {"a": 2, "b": 3}}\n</tool_call><|im_end|>\n'
+
+    >>> tokenizer.apply_chat_template(messages2, tokenize=False, add_generation_prompt=True)
+    '<|im_start|>user\nWhat is 2 * 3?<|im_end|>\n<|im_start|>assistant\n<tool_call>\n{"name": "multiply", "arguments": {"a": 2, "b": 3}}\n</tool_call><|im_end|>\n<|im_start|>user\n<tool_response>\n6\n</tool_response><|im_end|>\n<|im_start|>assistant\n'
+
+    >>> #                                                        ^ think tags missing
+    >>> chat_template = get_training_chat_template(tokenizer)
+    >>> tokenizer.apply_chat_template(messages1, tokenize=False, chat_template=chat_template)
+    '<|im_start|>user\nWhat is 2 * 3?<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n{"name": "multiply", "arguments": {"a": 2, "b": 3}}\n</tool_call><|im_end|>\n'
+
+    >>> tokenizer.apply_chat_template(
+    ...     messages2, tokenize=False, add_generation_prompt=True, chat_template=chat_template
+    ... )
+    '<|im_start|>user\nWhat is 2 * 3?<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n{"name": "multiply", "arguments": {"a": 2, "b": 3}}\n</tool_call><|im_end|>\n<|im_start|>user\n<tool_response>\n6\n</tool_response><|im_end|>\n<|im_start|>assistant\n'
+    ```
+    """
+    # First check if patching is needed
+    if is_chat_template_prefix_preserving(tokenizer) and "{% generation %}" in tokenizer.chat_template:
+        return None  # No patching needed
+
+    if tokenizer.chat_template == qwen3_chat_template:
+        return qwen3_training_chat_template
+    elif tokenizer.chat_template == gptoss_chat_template:
+        return gptoss_training_chat_template
+    else:
+        raise ValueError(
+            "The tokenizer's chat template is not training-compatible (missing prefix-preservation or "
+            "`{% generation %}` markers) and patching is not supported for this template. "
+            "Please manually modify the tokenizer's chat template for training."
+        )
+
+
+def _validate_tool_calls(tool_calls: list | None) -> None:
+    """
+    Validate tool_calls to ensure all required fields exist with valid values.
+
+    Raises ValueError when the model generates malformed tool calls (e.g., missing 'arguments' field) that are
+    partially parsed.
+
+    Args:
+        tool_calls: List of tool call dictionaries, or None.
+    """
+    if tool_calls is None:
+        return None
+    if not isinstance(tool_calls, list):
+        raise ValueError("tool_calls must be a list or None.")
+
+    for idx, tool_call in enumerate(tool_calls):
+        if not isinstance(tool_call, dict):
+            raise ValueError(f"tool_calls[{idx}] must be a dict.")
+
+        # Handle nested function structure: {"type": "function", "function": {"name": ..., "arguments": ...}}
+        if "function" in tool_call:
+            func = tool_call["function"]
+            if not isinstance(func, dict):
+                raise ValueError(f"tool_calls[{idx}]['function'] must be a dict.")
+            if not isinstance(func.get("name"), str):
+                raise ValueError(f"tool_calls[{idx}]['function']['name'] must be a string.")
+            # Some templates (e.g. Qwen3.5) omit arguments for valid no-arg calls; normalize to {}.
+            if "arguments" not in func or func["arguments"] is None:
+                func["arguments"] = {}
+        else:
+            # Handle flat structure: {"name": ..., "arguments": ...}
+            if not isinstance(tool_call.get("name"), str):
+                raise ValueError(f"tool_calls[{idx}]['name'] must be a string.")
+            # Some templates (e.g. Qwen3.5) omit arguments for valid no-arg calls; normalize to {}.
+            if "arguments" not in tool_call or tool_call["arguments"] is None:
+                tool_call["arguments"] = {}
+
+
+def parse_response(tokenizer_or_processor, ids: list[int]) -> dict:
+    r"""
+    Parse a token sequence into structured response dictionaries with fallback handling.
+
+    Attempts to parse the sequence using `tokenizer.parse_response()`. If parsing fails (e.g., due to malformed tool
+    calls like `<tool_call>{"type":"function"</tool_call>`), falls back to decoding as plain text.
+
+    Also removes incorrectly appended EOS tokens from tool call content when present, and validates tool_calls to
+    ensure all required fields exist.
+
+    For VLM processors, automatically uses the inner tokenizer for parsing.
+
+    Args:
+        tokenizer_or_processor (`PreTrainedTokenizer` or VLM processor):
+            Tokenizer or processor with a `parse_response()` method (directly or via inner tokenizer).
+        ids (`list[int]`):
+            List of token sequences.
+
+    Returns:
+        `dict`:
+            Response dictionary.
+
+    Example:
+    ```python
+    >>> from trl.chat_template_utils import parse_response, add_response_schema
+    >>> from transformers import AutoTokenizer
+
+    >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
+    >>> tokenizer = add_response_schema(tokenizer)  # temporary until built-in support
+    >>> text = '<tool_call>\n{"name": "multiply", "arguments": {"a": 3, "b": 4}}\n</tool_call><|im_end|>'
+    >>> ids = tokenizer(text)["input_ids"]
+    >>> parse_response(tokenizer, ids)
+    {'role': 'assistant', 'content': '', 'tool_calls': [{'type': 'function', 'function': {'name': 'multiply', 'arguments': {'a': 3, 'b': 4}}}]}
+    ```
+    """
+    # VLM processors don't have parse_response directly; use the inner tokenizer
+    tokenizer = getattr(tokenizer_or_processor, "tokenizer", tokenizer_or_processor)
+    try:
+        parsed = tokenizer.parse_response(ids)
+        # Hotfix: remove incorrectly appended EOS token from tool calls
+        # See https://github.com/huggingface/transformers/issues/42249
+        if isinstance(parsed.get("content"), str):
+            parsed["content"] = parsed["content"].removesuffix(tokenizer.eos_token)
+        # Normalize: ensure content is always a string (some models omit it or set it to None)
+        if not parsed.get("content"):
+            parsed["content"] = ""
+        # Validate tool_calls to prevent Jinja2 Undefined errors when fields are missing
+        if "tool_calls" in parsed:
+            _validate_tool_calls(parsed["tool_calls"])
+    except (ValueError, TypeError):
+        # Fallback: decode as plain text if parsing fails. This happens if the model outputs malformed tool calls.
+        content = tokenizer.decode(ids, skip_special_tokens=True)
+        parsed = {"role": "assistant", "content": content}
+    return parsed

tasks/tasksmith-0ea2241cceeb/environment/source/trl/chat_templates/README.md

@@ -0,0 +1,65 @@
+# Chat Templates
+
+Jinja2 chat templates stored here serve two purposes:
+
+1. **Identity comparison**: detecting which model is being used (by comparing `tokenizer.chat_template` against known templates) to add the appropriate response schema (`add_response_schema`) or swap in a training template (`get_training_chat_template`).
+2. **Training patches**: modified templates that fix training-specific issues (prefix-preservation for GRPO, `{% generation %}` markers for SFT assistant-only loss).
+
+**Why prefix-preserving?** The GRPO tool call loop extracts tool response formatting tokens by comparing tokenizations with and without tool messages appended (`_get_tool_suffix_ids`). This requires the chat template to be *prefix-preserving*: appending messages must not change how earlier messages are rendered.
+
+**Why generation-tagged?** SFT with `assistant_only_loss=True` requires the chat template to include `{% generation %}` / `{% endgeneration %}` markers around assistant output, so `return_assistant_tokens_mask=True` can produce correct masks. Most model templates don't include these markers natively.
+
+## Original templates
+
+Used for identity comparison only.
+
+### `gptoss.jinja`
+
+Original GPT-OSS chat template.
+
+### `qwen3.jinja`
+
+Original Qwen3 chat template.
+
+### `qwen3_5_2b_and_below.jinja` / `qwen3_5_4b_and_above.jinja`
+
+Original Qwen3.5 chat templates.
+
+## Training templates
+
+Patched templates that fix training-specific issues. Swapped in at init when tools are enabled (GRPO) or when `assistant_only_loss=True` (SFT).
+
+### `qwen3_training.jinja`
+
+Patched Qwen3 template. Diff vs `qwen3.jinja`:
+
+Require both `<think>` and `</think>` to be present before parsing, to avoid incorrect splitting when the model generates only one tag:
+
+```diff
+- {%- if '</think>' in content %}
++ {%- if '<think>' in content and '</think>' in content %}
+```
+
+Always include the thinking block regardless of message position. The original conditionally omits it based on `loop.last`, which changes the assistant rendering when a tool message is appended — breaking prefix-preservation:
+
+```diff
+- {%- if loop.index0 > ns.last_query_index %}
+-     {%- if loop.last or (not loop.last and reasoning_content) %}
+-         {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+-     {%- else %}
+-         {{- '<|im_start|>' + message.role + '\n' + content }}
+-     {%- endif %}
+- {%- else %}
+-     {{- '<|im_start|>' + message.role + '\n' + content }}
+- {%- endif %}
++ {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+```
+
+Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss.
+
+### `gptoss_training.jinja`
+
+Patched GPT-OSS template. Diff vs `gptoss.jinja`:
+
+Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that
+`return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss.

tasks/tasksmith-0ea2241cceeb/environment/source/trl/chat_templates/gptoss.jinja

@@ -0,0 +1,331 @@
+{#-
+  In addition to the normal inputs of `messages` and `tools`, this template also accepts the
+  following kwargs:
+  - "builtin_tools": A list, can contain "browser" and/or "python".
+  - "model_identity": A string that optionally describes the model identity.
+  - "reasoning_effort": A string that describes the reasoning effort, defaults to "medium".
+ #}
+
+{#- Tool Definition Rendering ============================================== #}
+{%- macro render_typescript_type(param_spec, required_params, is_nullable=false) -%}
+    {%- if param_spec.type == "array" -%}
+        {%- if param_spec['items'] -%}
+            {%- if param_spec['items']['type'] == "string" -%}
+                {{- "string[]" }}
+            {%- elif param_spec['items']['type'] == "number" -%}
+                {{- "number[]" }}
+            {%- elif param_spec['items']['type'] == "integer" -%}
+                {{- "number[]" }}
+            {%- elif param_spec['items']['type'] == "boolean" -%}
+                {{- "boolean[]" }}
+            {%- else -%}
+                {%- set inner_type = render_typescript_type(param_spec['items'], required_params) -%}
+                {%- if inner_type == "object | object" or inner_type|length > 50 -%}
+                    {{- "any[]" }}
+                {%- else -%}
+                    {{- inner_type + "[]" }}
+                {%- endif -%}
+            {%- endif -%}
+            {%- if param_spec.nullable -%}
+                {{- " | null" }}
+            {%- endif -%}
+        {%- else -%}
+            {{- "any[]" }}
+            {%- if param_spec.nullable -%}
+                {{- " | null" }}
+            {%- endif -%}
+        {%- endif -%}
+    {%- elif param_spec.type is defined and param_spec.type is iterable and param_spec.type is not string and param_spec.type is not mapping and param_spec.type[0] is defined -%}
+        {#- Handle array of types like ["object", "object"] from Union[dict, list] #}
+        {%- if param_spec.type | length > 1 -%}
+            {{- param_spec.type | join(" | ") }}
+        {%- else -%}
+            {{- param_spec.type[0] }}
+        {%- endif -%}
+    {%- elif param_spec.oneOf -%}
+        {#- Handle oneOf schemas - check for complex unions and fallback to any #}
+        {%- set has_object_variants = false -%}
+        {%- for variant in param_spec.oneOf -%}
+            {%- if variant.type == "object" -%}
+                {%- set has_object_variants = true -%}
+            {%- endif -%}
+        {%- endfor -%}
+        {%- if has_object_variants and param_spec.oneOf|length > 1 -%}
+            {{- "any" }}
+        {%- else -%}
+            {%- for variant in param_spec.oneOf -%}
+                {{- render_typescript_type(variant, required_params) -}}
+                {%- if variant.description %}
+                    {{- "// " + variant.description }}
+                {%- endif -%}
+                {%- if variant.default is defined %}
+                    {{ "// default: " + variant.default|tojson }}
+                {%- endif -%}
+                {%- if not loop.last %}
+                    {{- " | " }}
+                {% endif -%}
+            {%- endfor -%}
+        {%- endif -%}
+    {%- elif param_spec.type == "string" -%}
+        {%- if param_spec.enum -%}
+            {{- '"' + param_spec.enum|join('" | "') + '"' -}}
+        {%- else -%}
+            {{- "string" }}
+            {%- if param_spec.nullable %}
+                {{- " | null" }}
+            {%- endif -%}
+        {%- endif -%}
+    {%- elif param_spec.type == "number" -%}
+        {{- "number" }}
+    {%- elif param_spec.type == "integer" -%}
+        {{- "number" }}
+    {%- elif param_spec.type == "boolean" -%}
+        {{- "boolean" }}
+
+    {%- elif param_spec.type == "object" -%}
+        {%- if param_spec.properties -%}
+            {{- "{\n" }}
+            {%- for prop_name, prop_spec in param_spec.properties.items() -%}
+                {{- prop_name -}}
+                {%- if prop_name not in (param_spec.required or []) -%}
+                    {{- "?" }}
+                {%- endif -%}
+                {{- ": " }}
+                {{ render_typescript_type(prop_spec, param_spec.required or []) }}
+                {%- if not loop.last -%}
+                    {{-", " }}
+                {%- endif -%}
+            {%- endfor -%}
+            {{- "}" }}
+        {%- else -%}
+            {{- "object" }}
+        {%- endif -%}
+    {%- else -%}
+        {{- "any" }}
+    {%- endif -%}
+{%- endmacro -%}
+
+{%- macro render_tool_namespace(namespace_name, tools) -%}
+    {{- "## " + namespace_name + "\n\n" }}
+    {{- "namespace " + namespace_name + " {\n\n" }}
+    {%- for tool in tools %}
+        {%- set tool = tool.function %}
+        {{- "// " + tool.description + "\n" }}
+        {{- "type "+ tool.name + " = " }}
+        {%- if tool.parameters and tool.parameters.properties %}
+            {{- "(_: {\n" }}
+            {%- for param_name, param_spec in tool.parameters.properties.items() %}
+                {%- if param_spec.description %}
+                    {{- "// " + param_spec.description + "\n" }}
+                {%- endif %}
+                {{- param_name }}
+                {%- if param_name not in (tool.parameters.required or []) -%}
+                    {{- "?" }}
+                {%- endif -%}
+                {{- ": " }}
+                {{- render_typescript_type(param_spec, tool.parameters.required or []) }}
+                {%- if param_spec.default is defined -%}
+                    {%- if param_spec.enum %}
+                        {{- ", // default: " + param_spec.default }}
+                    {%- elif param_spec.oneOf %}
+                        {{- "// default: " + param_spec.default }}
+                    {%- else %}
+                        {{- ", // default: " + param_spec.default|tojson }}
+                    {%- endif -%}
+                {%- endif -%}
+                {%- if not loop.last %}
+                    {{- ",\n" }}
+                {%- else %}
+                    {{- ",\n" }}
+                {%- endif -%}
+            {%- endfor %}
+            {{- "}) => any;\n\n" }}
+        {%- else -%}
+            {{- "() => any;\n\n" }}
+        {%- endif -%}
+    {%- endfor %}
+    {{- "} // namespace " + namespace_name }}
+{%- endmacro -%}
+
+{%- macro render_builtin_tools(browser_tool, python_tool) -%}
+    {%- if browser_tool %}
+        {{- "## browser\n\n" }}
+        {{- "// Tool for browsing.\n" }}
+        {{- "// The `cursor` appears in brackets before each browsing display: `[{cursor}]`.\n" }}
+        {{- "// Cite information from the tool using the following format:\n" }}
+        {{- "// `【{cursor}†L{line_start}(-L{line_end})?】`, for example: `【6†L9-L11】` or `【8†L3】`.\n" }}
+        {{- "// Do not quote more than 10 words directly from the tool output.\n" }}
+        {{- "// sources=web (default: web)\n" }}
+        {{- "namespace browser {\n\n" }}
+        {{- "// Searches for information related to `query` and displays `topn` results.\n" }}
+        {{- "type search = (_: {\n" }}
+        {{- "query: string,\n" }}
+        {{- "topn?: number, // default: 10\n" }}
+        {{- "source?: string,\n" }}
+        {{- "}) => any;\n\n" }}
+        {{- "// Opens the link `id` from the page indicated by `cursor` starting at line number `loc`, showing `num_lines` lines.\n" }}
+        {{- "// Valid link ids are displayed with the formatting: `【{id}†.*】`.\n" }}
+        {{- "// If `cursor` is not provided, the most recent page is implied.\n" }}
+        {{- "// If `id` is a string, it is treated as a fully qualified URL associated with `source`.\n" }}
+        {{- "// If `loc` is not provided, the viewport will be positioned at the beginning of the document or centered on the most relevant passage, if available.\n" }}
+        {{- "// Use this function without `id` to scroll to a new location of an opened page.\n" }}
+        {{- "type open = (_: {\n" }}
+        {{- "id?: number | string, // default: -1\n" }}
+        {{- "cursor?: number, // default: -1\n" }}
+        {{- "loc?: number, // default: -1\n" }}
+        {{- "num_lines?: number, // default: -1\n" }}
+        {{- "view_source?: boolean, // default: false\n" }}
+        {{- "source?: string,\n" }}
+        {{- "}) => any;\n\n" }}
+        {{- "// Finds exact matches of `pattern` in the current page, or the page given by `cursor`.\n" }}
+        {{- "type find = (_: {\n" }}
+        {{- "pattern: string,\n" }}
+        {{- "cursor?: number, // default: -1\n" }}
+        {{- "}) => any;\n\n" }}
+        {{- "} // namespace browser\n\n" }}
+    {%- endif -%}
+
+    {%- if python_tool %}
+        {{- "## python\n\n" }}
+        {{- "Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).\n\n" }}
+        {{- "When you send a message containing Python code to python, it will be executed in a stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 120.0 seconds. The drive at '/mnt/data' can be used to save and persist user files. Internet access for this session is UNKNOWN. Depends on the cluster.\n\n" }}
+    {%- endif -%}
+{%- endmacro -%}
+
+{#- System Message Construction ============================================ #}
+{%- macro build_system_message() -%}
+    {%- if model_identity is not defined %}
+        {%- set model_identity = "You are ChatGPT, a large language model trained by OpenAI." %}
+    {%- endif %}
+    {{- model_identity + "\n" }}
+    {{- "Knowledge cutoff: 2024-06\n" }}
+    {{- "Current date: " + strftime_now("%Y-%m-%d") + "\n\n" }}
+    {%- if reasoning_effort is not defined %}
+        {%- set reasoning_effort = "medium" %}
+    {%- endif %}
+    {{- "Reasoning: " + reasoning_effort + "\n\n" }}
+    {%- if builtin_tools %}
+        {{- "# Tools\n\n" }}
+        {%- set available_builtin_tools = namespace(browser=false, python=false) %}
+        {%- for tool in builtin_tools %}
+            {%- if tool == "browser" %}
+                {%- set available_builtin_tools.browser = true %}
+            {%- elif tool == "python" %}
+                {%- set available_builtin_tools.python = true %}
+            {%- endif %}
+        {%- endfor %}
+        {{- render_builtin_tools(available_builtin_tools.browser, available_builtin_tools.python) }}
+    {%- endif -%}
+    {{- "# Valid channels: analysis, commentary, final. Channel must be included for every message." }}
+    {%- if tools -%}
+        {{- "\nCalls to these tools must go to the commentary channel: 'functions'." }}
+    {%- endif -%}
+{%- endmacro -%}
+
+{#- Main Template Logic ================================================= #}
+{#- Set defaults #}
+
+{#- Render system message #}
+{{- "<|start|>system<|message|>" }}
+{{- build_system_message() }}
+{{- "<|end|>" }}
+
+{#- Extract developer message #}
+{%- if messages[0].role == "developer" or messages[0].role == "system" %}
+    {%- set developer_message = messages[0].content %}
+    {%- set loop_messages = messages[1:] %}
+{%- else %}
+    {%- set developer_message = "" %}
+    {%- set loop_messages = messages %}
+{%- endif %}
+
+{#- Render developer message #}
+{%- if developer_message or tools %}
+    {{- "<|start|>developer<|message|>" }}
+    {%- if developer_message %}
+        {{- "# Instructions\n\n" }}
+        {{- developer_message }}
+        {{- "\n\n" }}
+    {%- endif %}
+    {%- if tools -%}
+        {{- "# Tools\n\n" }}
+        {{- render_tool_namespace("functions", tools) }}
+    {%- endif -%}
+    {{- "<|end|>" }}
+{%- endif %}
+
+{#- Render messages #}
+{%- set last_tool_call = namespace(name=none) %}
+{%- for message in loop_messages -%}
+    {#- At this point only assistant/user/tool messages should remain #}
+    {%- if message.role == 'assistant' -%}
+        {#- Checks to ensure the messages are being passed in the format we expect #}
+        {%- if "content" in message %}
+            {%- if "<|channel|>analysis<|message|>" in message.content or "<|channel|>final<|message|>" in message.content %}
+                {{- raise_exception("You have passed a message containing <|channel|> tags in the content field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }}
+            {%- endif %}
+        {%- endif %}
+        {%- if "thinking" in message %}
+            {%- if "<|channel|>analysis<|message|>" in message.thinking or "<|channel|>final<|message|>" in message.thinking %}
+                {{- raise_exception("You have passed a message containing <|channel|> tags in the thinking field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }}
+            {%- endif %}
+        {%- endif %}
+        {%- if "tool_calls" in message %}
+            {#- We need very careful handling here - we want to drop the tool call analysis message if the model #}
+            {#- has output a later <|final|> message, but otherwise we want to retain it. This is the only case #}
+            {#- when we render CoT/analysis messages in inference. #}
+            {%- set future_final_message = namespace(found=false) %}
+            {%- for future_message in loop_messages[loop.index:] %}
+                {%- if future_message.role == 'assistant' and "tool_calls" not in future_message %}
+                    {%- set future_final_message.found = true %}
+                {%- endif %}
+            {%- endfor %}
+            {#- We assume max 1 tool call per message, and so we infer the tool call name #}
+            {#- in "tool" messages from the most recent assistant tool call name #}
+            {%- set tool_call = message.tool_calls[0] %}
+            {%- if tool_call.function %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {%- if message.content and message.thinking %}
+                {{- raise_exception("Cannot pass both content and thinking in an assistant message with tool calls! Put the analysis message in one or the other, but not both.") }}
+            {%- elif message.content and not future_final_message.found %}
+                {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.content + "<|end|>" }}
+            {%- elif message.thinking and not future_final_message.found %}
+                {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }}
+            {%- endif %}
+            {{- "<|start|>assistant to=" }}
+            {{- "functions." + tool_call.name + "<|channel|>commentary " }}
+            {{- (tool_call.content_type if tool_call.content_type is defined else "json") + "<|message|>" }}
+            {{- tool_call.arguments|tojson }}
+            {{- "<|call|>" }}
+            {%- set last_tool_call.name = tool_call.name %}
+        {%- elif loop.last and not add_generation_prompt %}
+            {#- Only render the CoT if the final turn is an assistant turn and add_generation_prompt is false #}
+            {#- This is a situation that should only occur in training, never in inference. #}
+            {%- if "thinking" in message %}
+                {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }}
+            {%- endif %}
+            {#- <|return|> indicates the end of generation, but <|end|> does not #}
+            {#- <|return|> should never be an input to the model, but we include it as the final token #}
+            {#- when training, so the model learns to emit it. #}
+            {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|return|>" }}
+        {%- else %}
+            {#- CoT is dropped during all previous turns, so we never render it for inference #}
+            {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|end|>" }}
+            {%- set last_tool_call.name = none %}
+        {%- endif %}
+    {%- elif message.role == 'tool' -%}
+        {%- if last_tool_call.name is none %}
+            {{- raise_exception("Message has tool role, but there was no previous assistant message with a tool call!") }}
+        {%- endif %}
+        {{- "<|start|>functions." + last_tool_call.name }}
+        {{- " to=assistant<|channel|>commentary<|message|>" + message.content|tojson + "<|end|>" }}
+    {%- elif message.role == 'user' -%}
+        {{- "<|start|>user<|message|>" + message.content + "<|end|>" }}
+    {%- endif -%}
+{%- endfor -%}
+
+{#- Generation prompt #}
+{%- if add_generation_prompt -%}
+<|start|>assistant
+{%- endif -%}

tasks/tasksmith-0ea2241cceeb/environment/source/trl/chat_templates/gptoss_training.jinja

@@ -0,0 +1,338 @@
+{#-
+  Training variant of the GPT-OSS chat template (see gptoss.jinja for the original).
+  Modifications vs the original:
+    - Added {% generation %} / {% endgeneration %} around assistant message output to support
+      assistant-only loss masking in SFT training.
+
+  In addition to the normal inputs of `messages` and `tools`, this template also accepts the
+  following kwargs:
+  - "builtin_tools": A list, can contain "browser" and/or "python".
+  - "model_identity": A string that optionally describes the model identity.
+  - "reasoning_effort": A string that describes the reasoning effort, defaults to "medium".
+ #}
+
+{#- Tool Definition Rendering ============================================== #}
+{%- macro render_typescript_type(param_spec, required_params, is_nullable=false) -%}
+    {%- if param_spec.type == "array" -%}
+        {%- if param_spec['items'] -%}
+            {%- if param_spec['items']['type'] == "string" -%}
+                {{- "string[]" }}
+            {%- elif param_spec['items']['type'] == "number" -%}
+                {{- "number[]" }}
+            {%- elif param_spec['items']['type'] == "integer" -%}
+                {{- "number[]" }}
+            {%- elif param_spec['items']['type'] == "boolean" -%}
+                {{- "boolean[]" }}
+            {%- else -%}
+                {%- set inner_type = render_typescript_type(param_spec['items'], required_params) -%}
+                {%- if inner_type == "object | object" or inner_type|length > 50 -%}
+                    {{- "any[]" }}
+                {%- else -%}
+                    {{- inner_type + "[]" }}
+                {%- endif -%}
+            {%- endif -%}
+            {%- if param_spec.nullable -%}
+                {{- " | null" }}
+            {%- endif -%}
+        {%- else -%}
+            {{- "any[]" }}
+            {%- if param_spec.nullable -%}
+                {{- " | null" }}
+            {%- endif -%}
+        {%- endif -%}
+    {%- elif param_spec.type is defined and param_spec.type is iterable and param_spec.type is not string and param_spec.type is not mapping and param_spec.type[0] is defined -%}
+        {#- Handle array of types like ["object", "object"] from Union[dict, list] #}
+        {%- if param_spec.type | length > 1 -%}
+            {{- param_spec.type | join(" | ") }}
+        {%- else -%}
+            {{- param_spec.type[0] }}
+        {%- endif -%}
+    {%- elif param_spec.oneOf -%}
+        {#- Handle oneOf schemas - check for complex unions and fallback to any #}
+        {%- set has_object_variants = false -%}
+        {%- for variant in param_spec.oneOf -%}
+            {%- if variant.type == "object" -%}
+                {%- set has_object_variants = true -%}
+            {%- endif -%}
+        {%- endfor -%}
+        {%- if has_object_variants and param_spec.oneOf|length > 1 -%}
+            {{- "any" }}
+        {%- else -%}
+            {%- for variant in param_spec.oneOf -%}
+                {{- render_typescript_type(variant, required_params) -}}
+                {%- if variant.description %}
+                    {{- "// " + variant.description }}
+                {%- endif -%}
+                {%- if variant.default is defined %}
+                    {{ "// default: " + variant.default|tojson }}
+                {%- endif -%}
+                {%- if not loop.last %}
+                    {{- " | " }}
+                {% endif -%}
+            {%- endfor -%}
+        {%- endif -%}
+    {%- elif param_spec.type == "string" -%}
+        {%- if param_spec.enum -%}
+            {{- '"' + param_spec.enum|join('" | "') + '"' -}}
+        {%- else -%}
+            {{- "string" }}
+            {%- if param_spec.nullable %}
+                {{- " | null" }}
+            {%- endif -%}
+        {%- endif -%}
+    {%- elif param_spec.type == "number" -%}
+        {{- "number" }}
+    {%- elif param_spec.type == "integer" -%}
+        {{- "number" }}
+    {%- elif param_spec.type == "boolean" -%}
+        {{- "boolean" }}
+
+    {%- elif param_spec.type == "object" -%}
+        {%- if param_spec.properties -%}
+            {{- "{\n" }}
+            {%- for prop_name, prop_spec in param_spec.properties.items() -%}
+                {{- prop_name -}}
+                {%- if prop_name not in (param_spec.required or []) -%}
+                    {{- "?" }}
+                {%- endif -%}
+                {{- ": " }}
+                {{ render_typescript_type(prop_spec, param_spec.required or []) }}
+                {%- if not loop.last -%}
+                    {{-", " }}
+                {%- endif -%}
+            {%- endfor -%}
+            {{- "}" }}
+        {%- else -%}
+            {{- "object" }}
+        {%- endif -%}
+    {%- else -%}
+        {{- "any" }}
+    {%- endif -%}
+{%- endmacro -%}
+
+{%- macro render_tool_namespace(namespace_name, tools) -%}
+    {{- "## " + namespace_name + "\n\n" }}
+    {{- "namespace " + namespace_name + " {\n\n" }}
+    {%- for tool in tools %}
+        {%- set tool = tool.function %}
+        {{- "// " + tool.description + "\n" }}
+        {{- "type "+ tool.name + " = " }}
+        {%- if tool.parameters and tool.parameters.properties %}
+            {{- "(_: {\n" }}
+            {%- for param_name, param_spec in tool.parameters.properties.items() %}
+                {%- if param_spec.description %}
+                    {{- "// " + param_spec.description + "\n" }}
+                {%- endif %}
+                {{- param_name }}
+                {%- if param_name not in (tool.parameters.required or []) -%}
+                    {{- "?" }}
+                {%- endif -%}
+                {{- ": " }}
+                {{- render_typescript_type(param_spec, tool.parameters.required or []) }}
+                {%- if param_spec.default is defined -%}
+                    {%- if param_spec.enum %}
+                        {{- ", // default: " + param_spec.default }}
+                    {%- elif param_spec.oneOf %}
+                        {{- "// default: " + param_spec.default }}
+                    {%- else %}
+                        {{- ", // default: " + param_spec.default|tojson }}
+                    {%- endif -%}
+                {%- endif -%}
+                {%- if not loop.last %}
+                    {{- ",\n" }}
+                {%- else %}
+                    {{- ",\n" }}
+                {%- endif -%}
+            {%- endfor %}
+            {{- "}) => any;\n\n" }}
+        {%- else -%}
+            {{- "() => any;\n\n" }}
+        {%- endif -%}
+    {%- endfor %}
+    {{- "} // namespace " + namespace_name }}
+{%- endmacro -%}
+
+{%- macro render_builtin_tools(browser_tool, python_tool) -%}
+    {%- if browser_tool %}
+        {{- "## browser\n\n" }}
+        {{- "// Tool for browsing.\n" }}
+        {{- "// The `cursor` appears in brackets before each browsing display: `[{cursor}]`.\n" }}
+        {{- "// Cite information from the tool using the following format:\n" }}
+        {{- "// `【{cursor}†L{line_start}(-L{line_end})?】`, for example: `【6†L9-L11】` or `【8†L3】`.\n" }}
+        {{- "// Do not quote more than 10 words directly from the tool output.\n" }}
+        {{- "// sources=web (default: web)\n" }}
+        {{- "namespace browser {\n\n" }}
+        {{- "// Searches for information related to `query` and displays `topn` results.\n" }}
+        {{- "type search = (_: {\n" }}
+        {{- "query: string,\n" }}
+        {{- "topn?: number, // default: 10\n" }}
+        {{- "source?: string,\n" }}
+        {{- "}) => any;\n\n" }}
+        {{- "// Opens the link `id` from the page indicated by `cursor` starting at line number `loc`, showing `num_lines` lines.\n" }}
+        {{- "// Valid link ids are displayed with the formatting: `【{id}†.*】`.\n" }}
+        {{- "// If `cursor` is not provided, the most recent page is implied.\n" }}
+        {{- "// If `id` is a string, it is treated as a fully qualified URL associated with `source`.\n" }}
+        {{- "// If `loc` is not provided, the viewport will be positioned at the beginning of the document or centered on the most relevant passage, if available.\n" }}
+        {{- "// Use this function without `id` to scroll to a new location of an opened page.\n" }}
+        {{- "type open = (_: {\n" }}
+        {{- "id?: number | string, // default: -1\n" }}
+        {{- "cursor?: number, // default: -1\n" }}
+        {{- "loc?: number, // default: -1\n" }}
+        {{- "num_lines?: number, // default: -1\n" }}
+        {{- "view_source?: boolean, // default: false\n" }}
+        {{- "source?: string,\n" }}
+        {{- "}) => any;\n\n" }}
+        {{- "// Finds exact matches of `pattern` in the current page, or the page given by `cursor`.\n" }}
+        {{- "type find = (_: {\n" }}
+        {{- "pattern: string,\n" }}
+        {{- "cursor?: number, // default: -1\n" }}
+        {{- "}) => any;\n\n" }}
+        {{- "} // namespace browser\n\n" }}
+    {%- endif -%}
+
+    {%- if python_tool %}
+        {{- "## python\n\n" }}
+        {{- "Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).\n\n" }}
+        {{- "When you send a message containing Python code to python, it will be executed in a stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 120.0 seconds. The drive at '/mnt/data' can be used to save and persist user files. Internet access for this session is UNKNOWN. Depends on the cluster.\n\n" }}
+    {%- endif -%}
+{%- endmacro -%}
+
+{#- System Message Construction ============================================ #}
+{%- macro build_system_message() -%}
+    {%- if model_identity is not defined %}
+        {%- set model_identity = "You are ChatGPT, a large language model trained by OpenAI." %}
+    {%- endif %}
+    {{- model_identity + "\n" }}
+    {{- "Knowledge cutoff: 2024-06\n" }}
+    {{- "Current date: " + strftime_now("%Y-%m-%d") + "\n\n" }}
+    {%- if reasoning_effort is not defined %}
+        {%- set reasoning_effort = "medium" %}
+    {%- endif %}
+    {{- "Reasoning: " + reasoning_effort + "\n\n" }}
+    {%- if builtin_tools %}
+        {{- "# Tools\n\n" }}
+        {%- set available_builtin_tools = namespace(browser=false, python=false) %}
+        {%- for tool in builtin_tools %}
+            {%- if tool == "browser" %}
+                {%- set available_builtin_tools.browser = true %}
+            {%- elif tool == "python" %}
+                {%- set available_builtin_tools.python = true %}
+            {%- endif %}
+        {%- endfor %}
+        {{- render_builtin_tools(available_builtin_tools.browser, available_builtin_tools.python) }}
+    {%- endif -%}
+    {{- "# Valid channels: analysis, commentary, final. Channel must be included for every message." }}
+    {%- if tools -%}
+        {{- "\nCalls to these tools must go to the commentary channel: 'functions'." }}
+    {%- endif -%}
+{%- endmacro -%}
+
+{#- Main Template Logic ================================================= #}
+{#- Set defaults #}
+
+{#- Render system message #}
+{{- "<|start|>system<|message|>" }}
+{{- build_system_message() }}
+{{- "<|end|>" }}
+
+{#- Extract developer message #}
+{%- if messages[0].role == "developer" or messages[0].role == "system" %}
+    {%- set developer_message = messages[0].content %}
+    {%- set loop_messages = messages[1:] %}
+{%- else %}
+    {%- set developer_message = "" %}
+    {%- set loop_messages = messages %}
+{%- endif %}
+
+{#- Render developer message #}
+{%- if developer_message or tools %}
+    {{- "<|start|>developer<|message|>" }}
+    {%- if developer_message %}
+        {{- "# Instructions\n\n" }}
+        {{- developer_message }}
+        {{- "\n\n" }}
+    {%- endif %}
+    {%- if tools -%}
+        {{- "# Tools\n\n" }}
+        {{- render_tool_namespace("functions", tools) }}
+    {%- endif -%}
+    {{- "<|end|>" }}
+{%- endif %}
+
+{#- Render messages #}
+{%- set last_tool_call = namespace(name=none) %}
+{%- for message in loop_messages -%}
+    {#- At this point only assistant/user/tool messages should remain #}
+    {%- if message.role == 'assistant' -%}
+        {#- Checks to ensure the messages are being passed in the format we expect #}
+        {%- if "content" in message %}
+            {%- if "<|channel|>analysis<|message|>" in message.content or "<|channel|>final<|message|>" in message.content %}
+                {{- raise_exception("You have passed a message containing <|channel|> tags in the content field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }}
+            {%- endif %}
+        {%- endif %}
+        {%- if "thinking" in message %}
+            {%- if "<|channel|>analysis<|message|>" in message.thinking or "<|channel|>final<|message|>" in message.thinking %}
+                {{- raise_exception("You have passed a message containing <|channel|> tags in the thinking field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }}
+            {%- endif %}
+        {%- endif %}
+        {%- generation %}
+        {%- if "tool_calls" in message %}
+            {#- We need very careful handling here - we want to drop the tool call analysis message if the model #}
+            {#- has output a later <|final|> message, but otherwise we want to retain it. This is the only case #}
+            {#- when we render CoT/analysis messages in inference. #}
+            {%- set future_final_message = namespace(found=false) %}
+            {%- for future_message in loop_messages[loop.index:] %}
+                {%- if future_message.role == 'assistant' and "tool_calls" not in future_message %}
+                    {%- set future_final_message.found = true %}
+                {%- endif %}
+            {%- endfor %}
+            {#- We assume max 1 tool call per message, and so we infer the tool call name #}
+            {#- in "tool" messages from the most recent assistant tool call name #}
+            {%- set tool_call = message.tool_calls[0] %}
+            {%- if tool_call.function %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {%- if message.content and message.thinking %}
+                {{- raise_exception("Cannot pass both content and thinking in an assistant message with tool calls! Put the analysis message in one or the other, but not both.") }}
+            {%- elif message.content and not future_final_message.found %}
+                {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.content + "<|end|>" }}
+            {%- elif message.thinking and not future_final_message.found %}
+                {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }}
+            {%- endif %}
+            {{- "<|start|>assistant to=" }}
+            {{- "functions." + tool_call.name + "<|channel|>commentary " }}
+            {{- (tool_call.content_type if tool_call.content_type is defined else "json") + "<|message|>" }}
+            {{- tool_call.arguments|tojson }}
+            {{- "<|call|>" }}
+            {%- set last_tool_call.name = tool_call.name %}
+        {%- elif loop.last and not add_generation_prompt %}
+            {#- Only render the CoT if the final turn is an assistant turn and add_generation_prompt is false #}
+            {#- This is a situation that should only occur in training, never in inference. #}
+            {%- if "thinking" in message %}
+                {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }}
+            {%- endif %}
+            {#- <|return|> indicates the end of generation, but <|end|> does not #}
+            {#- <|return|> should never be an input to the model, but we include it as the final token #}
+            {#- when training, so the model learns to emit it. #}
+            {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|return|>" }}
+        {%- else %}
+            {#- CoT is dropped during all previous turns, so we never render it for inference #}
+            {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|end|>" }}
+            {%- set last_tool_call.name = none %}
+        {%- endif %}
+        {%- endgeneration %}
+    {%- elif message.role == 'tool' -%}
+        {%- if last_tool_call.name is none %}
+            {{- raise_exception("Message has tool role, but there was no previous assistant message with a tool call!") }}
+        {%- endif %}
+        {{- "<|start|>functions." + last_tool_call.name }}
+        {{- " to=assistant<|channel|>commentary<|message|>" + message.content|tojson + "<|end|>" }}
+    {%- elif message.role == 'user' -%}
+        {{- "<|start|>user<|message|>" + message.content + "<|end|>" }}
+    {%- endif -%}
+{%- endfor -%}
+
+{#- Generation prompt #}
+{%- if add_generation_prompt -%}
+<|start|>assistant
+{%- endif -%}

tasks/tasksmith-0ea2241cceeb/environment/source/trl/chat_templates/qwen3.jinja

@@ -0,0 +1,89 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {%- if loop.last or (not loop.last and reasoning_content) %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+            {%- else %}
+                {{- '<|im_start|>' + message.role + '\n' + content }}
+            {%- endif %}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

tasks/tasksmith-0ea2241cceeb/environment/source/trl/chat_templates/qwen3_5_2b_and_below.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is true %}
+        {{- '<think>\n' }}
+    {%- else %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

tasks/tasksmith-0ea2241cceeb/environment/source/trl/chat_templates/qwen3_5_4b_and_above.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

tasks/tasksmith-0ea2241cceeb/environment/source/trl/chat_templates/qwen3_training.jinja

@@ -0,0 +1,93 @@
+{#- Training variant of the Qwen3 chat template (see qwen3.jinja for the original).
+    Modifications vs the original:
+    - {%- if '</think>' in content %} → {%- if '<think>' in content and '</think>' in content %}
+      Always check for both tags to avoid edge cases where the model generates only one tag.
+    - Removed the loop.index0 > ns.last_query_index conditional; always include thinking block.
+      This makes the template prefix-preserving for the [user, assistant] → [user, assistant, tool] transition.
+    - Added {% generation %} / {% endgeneration %} around assistant message output to support
+      assistant-only loss masking in SFT training.
+-#}
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '<think>' in content and '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- generation %}
+        {{- '<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+        {%- endgeneration %}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

tasks/tasksmith-0ea2241cceeb/environment/source/trl/cli/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .main import main
+
+
+__all__ = ["main"]

tasks/tasksmith-0ea2241cceeb/environment/source/trl/cli/accelerate_config.py

@@ -0,0 +1,47 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib.resources as resources
+from pathlib import Path
+
+
+def resolve_accelerate_config_argument(launch_args: list[str]) -> list[str]:
+    """
+    Resolve `--accelerate_config` from CLI arguments into `accelerate --config_file`.
+
+    The function supports either a filesystem path or a predefined config name shipped in `trl/accelerate_configs`
+    (without the `.yaml` suffix).
+    """
+    if "--accelerate_config" not in launch_args:
+        return launch_args
+
+    config_index = launch_args.index("--accelerate_config")
+    if config_index + 1 >= len(launch_args):
+        raise ValueError("Expected a value after `--accelerate_config`.")
+
+    config_name = launch_args[config_index + 1]
+    if Path(config_name).is_file():
+        accelerate_config_path = config_name
+    else:
+        candidate = resources.files("trl.accelerate_configs").joinpath(f"{config_name}.yaml")
+        if not candidate.exists():
+            raise ValueError(
+                f"Accelerate config {config_name} is neither a file nor a valid config in the `trl` package. "
+                "Please provide a valid config name or a path to a config file."
+            )
+        accelerate_config_path = candidate
+
+    # Remove '--accelerate_config <value>'.
+    launch_args = launch_args[:config_index] + launch_args[config_index + 2 :]
+    return ["--config_file", str(accelerate_config_path)] + launch_args

tasks/tasksmith-0ea2241cceeb/environment/source/trl/cli/accelerate_launcher.py

@@ -0,0 +1,47 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib.resources as resources
+from collections.abc import Callable
+from typing import Any
+
+from accelerate.commands.launch import launch_command, launch_command_parser
+
+
+def launch_training_script(
+    script_name: str,
+    launch_args: list[str],
+    training_script_args: list[str],
+    *,
+    launch_command_fn: Callable[[Any], None] = launch_command,
+    launch_parser_fn: Callable[[], Any] = launch_command_parser,
+) -> None:
+    """
+    Launch a TRL training script through `accelerate launch`.
+
+    Parameters:
+        script_name (`str`):
+            Script filename in `trl/scripts`, e.g. `"dpo.py"`.
+        launch_args (`list[str]`):
+            Arguments consumed by `accelerate launch`.
+        training_script_args (`list[str]`):
+            Arguments forwarded to the training script.
+        launch_command_fn (`Callable[[Any], None]`, *optional*):
+            Function used to execute accelerate launch.
+        launch_parser_fn (`Callable[[], Any]`, *optional*):
+            Factory creating the accelerate launch parser.
+    """
+    training_script = resources.files("trl.scripts").joinpath(script_name)
+    accelerate_args = launch_parser_fn().parse_args(launch_args + [str(training_script)] + training_script_args)
+    launch_command_fn(accelerate_args)

tasks/tasksmith-0ea2241cceeb/environment/source/trl/cli/commands/__init__.py

@@ -0,0 +1,37 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .base import Command
+from .env import EnvCommand
+from .skills import SkillsCommand
+from .training import TrainingCommand
+from .vllm_serve import VllmServeCommand
+
+
+def get_commands() -> list[Command]:
+    """Return all registered top-level TRL CLI commands."""
+    return [
+        TrainingCommand("dpo"),
+        EnvCommand(),
+        TrainingCommand("grpo"),
+        TrainingCommand("kto"),
+        TrainingCommand("reward"),
+        TrainingCommand("rloo"),
+        TrainingCommand("sft"),
+        SkillsCommand(),
+        VllmServeCommand(),
+    ]
+
+
+__all__ = ["Command", "get_commands"]

tasks/tasksmith-0ea2241cceeb/environment/source/trl/cli/commands/base.py

@@ -0,0 +1,62 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+from argparse import Namespace
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class CommandContext:
+    """Context shared by CLI commands during execution."""
+
+    argv: list[str]
+
+    def argv_after(self, token: str) -> list[str]:
+        """
+        Return CLI tokens after the first occurrence of `token`.
+
+        Parameters:
+            token (`str`):
+                Subcommand name as it appears in `argv`.
+        """
+        try:
+            index = self.argv.index(token)
+        except ValueError:
+            return []
+        return self.argv[index + 1 :]
+
+
+class Command(ABC):
+    """
+    Base command definition for the TRL CLI.
+
+    Parameters:
+        name (`str`):
+            Subcommand name exposed by the CLI.
+        help_text (`str`):
+            Short description displayed in help output.
+    """
+
+    def __init__(self, name: str, help_text: str):
+        self.name = name
+        self.help_text = help_text
+
+    @abstractmethod
+    def register(self, subparsers) -> None:
+        """Register this command parser in the subparser collection."""
+
+    @abstractmethod
+    def run(self, args: Namespace, context: CommandContext) -> int:
+        """Execute the command."""

tasks/tasksmith-0ea2241cceeb/environment/source/trl/cli/commands/env.py

@@ -0,0 +1,33 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from argparse import Namespace
+
+from .base import Command, CommandContext
+
+
+class EnvCommand(Command):
+    """CLI command that prints TRL environment information."""
+
+    def __init__(self):
+        super().__init__(name="env", help_text="Print the environment information")
+
+    def register(self, subparsers) -> None:
+        subparsers.add_parser(self.name, help=self.help_text)
+
+    def run(self, args: Namespace, context: CommandContext) -> int:
+        from ...scripts.env import print_env
+
+        print_env()
+        return 0

tasks/tasksmith-0ea2241cceeb/environment/source/trl/cli/commands/skills.py

@@ -0,0 +1,42 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from argparse import Namespace
+
+from ...skills.cli import add_skills_subcommands
+from .base import Command, CommandContext
+
+
+class SkillsCommand(Command):
+    """CLI command that manages TRL agent skills."""
+
+    def __init__(self):
+        super().__init__(name="skills", help_text="Manage TRL agent skills")
+        self._skills_parser = None
+
+    def register(self, subparsers) -> None:
+        self._skills_parser = subparsers.add_parser(self.name, help=self.help_text)
+        skills_subparsers = self._skills_parser.add_subparsers(dest="skills_command", help="Skills commands")
+        add_skills_subcommands(skills_subparsers)
+
+    def run(self, args: Namespace, context: CommandContext) -> int:
+        if getattr(args, "skills_command", None):
+            if hasattr(args, "func"):
+                return args.func(args)
+            print("Error: Unknown skills command")
+            return 1
+
+        if self._skills_parser is not None:
+            self._skills_parser.print_help()
+        return 0

tasks/tasksmith-0ea2241cceeb/environment/source/trl/cli/commands/training.py

@@ -0,0 +1,72 @@
+# Copyright 2020-2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+from argparse import Namespace
+
+from .base import Command, CommandContext
+
+
+def _subtract_subsequence(lst: list[str], subseq: list[str]) -> list[str]:
+    """Return lst with the ordered subsequence subseq removed."""
+    sub_iter = iter(subseq)
+    current = next(sub_iter, None)
+    result = []
+    for item in lst:
+        if current is not None and item == current:
+            current = next(sub_iter, None)
+        else:
+            result.append(item)
+    return result
+
+
+class TrainingCommand(Command):
+    """
+    Generic CLI command that launches a training script with accelerate.
+
+    The script `trl/scripts/<name>.py` must expose a `make_parser()` function.
+
+    Parameters:
+        name (`str`):
+            CLI subcommand name (e.g. `"dpo"`).
+    """
+
+    def __init__(self, name: str):
+        super().__init__(name=name, help_text=f"Run the {name} training script")
+
+    def register(self, subparsers) -> None:
+        subparsers.add_parser(self.name, help=self.help_text, add_help=False)
+
+    def run(self, args: Namespace, context: CommandContext) -> int:
+        from ..accelerate_config import resolve_accelerate_config_argument
+        from ..accelerate_launcher import launch_training_script
+
+        module = importlib.import_module(f"...scripts.{self.name}", package=__package__)
+        all_args = context.argv_after(self.name)
+        parser = module.make_parser(prog=f"trl {self.name}")
+
+        # Handles -h (exits). Returns config_remaining and cli_remaining separately.
+        # cli_remaining is an ordered subsequence of all_args; config_remaining is not.
+        *_, config_remaining, cli_remaining = parser.parse_args_and_config(
+            all_args, return_remaining_strings=True, separate_remaining_strings=True
+        )
+        launch_args = resolve_accelerate_config_argument(config_remaining + cli_remaining)
+        training_script_args = _subtract_subsequence(all_args, cli_remaining)
+
+        launch_training_script(
+            script_name=f"{self.name}.py",
+            launch_args=launch_args,
+            training_script_args=training_script_args,
+        )
+        return 0