ToolUse.1: benchmark corpus, harness and specification

SPEC.md

@@ -144,6 +144,14 @@ protocols, no few-shot examples, thinking/reasoning mode disabled by the runtime
 model supports it. `--resume` continues an interrupted run; `selftest` proves the grader agrees
 with the corpus before any model is loaded (oracle-style runners must score exactly 1.000).
 
+Decoding stops on every identifier a checkpoint declares for the end of a turn — the tokenizer
+`eos_token`, the generation config `eos_token_id`, and the model config `eos_token_id`, as a
+set. Qwen-style checkpoints routinely carry two of them (`<|im_end|>` closes the message, a
+pre-training `<|endoftext|>` sits in the model config), and stopping on only one of the pair
+makes a correct single call run to `max_new_tokens` and repeat itself, which the grader then
+scores as several calls in one turn. Stopping on the union measures the model instead of its
+tokenizer bookkeeping.
+
 Local runs may pass `--batch-size N` to evaluate N prompts in one padded `generate` call. Greedy
 decoding is unchanged by batching in theory but not bit-identical in practice (kernel reduction
 orders differ), so a borderline case can flip; report the batch size with the number, and use

tooluse1/harness.py

@@ -132,7 +132,7 @@ def _cmd_run(args: argparse.Namespace) -> int:
     )
     out_dir = Path(args.out)
     out_dir.mkdir(parents=True, exist_ok=True)
-    stem = f"{slugify(args.model or args.backend)}__{args.protocol}"
+    stem = f"{slugify(args.name or args.model or args.backend)}__{args.protocol}"
 
     existing = _dedupe(_load_results(out_dir / f"{stem}.json")) if args.resume else []
     done = {(result.case_id, result.protocol) for result in existing}
@@ -165,7 +165,7 @@ def _cmd_run(args: argparse.Namespace) -> int:
     def snapshot(partial: bool) -> dict[str, Any]:
         results = _dedupe(collected)
         results.sort(key=lambda item: (item.protocol, item.case_id))
-        report = build_report(results, model_id=runner.name if args.model else args.backend, protocol=args.protocol)
+        report = build_report(results, model_id=args.name or (runner.name if args.model else args.backend), protocol=args.protocol)
         if args.notes:
             report["notes"] = args.notes
         report["partial"] = partial
@@ -299,6 +299,7 @@ def build_parser() -> argparse.ArgumentParser:
         help="evaluations per generate call (local backends; 8-16 saturates a small GPU)",
     )
     run_parser.add_argument("--out", default=str(RESULTS_DIR))
+    run_parser.add_argument("--name", default="", help="human-readable run label; overrides the model path in the results file and filename")
     run_parser.add_argument("--notes", default="")
     run_parser.add_argument("--resume", action="store_true")
     run_parser.add_argument("--thinking", action="store_true", help="do not disable the model's reasoning mode")

tooluse1/runners.py

@@ -209,6 +209,7 @@ class TransformersRunner(Runner):
             self.tokenizer.pad_token = self.tokenizer.eos_token
         self.model, self.load_info = _load_model(model_id, dtype, device_map, trust_remote_code, revision)
         self.model.eval()
+        self._eos_ids = _end_of_turn_ids(self.model, self.tokenizer)
 
     def _render(self, messages: Sequence[Mapping[str, str]]) -> str:
         kwargs: dict[str, Any] = {"tokenize": False, "add_generation_prompt": True}
@@ -251,6 +252,7 @@ class TransformersRunner(Runner):
                 max_new_tokens=self.max_new_tokens,
                 do_sample=False,
                 pad_token_id=self.tokenizer.pad_token_id or self.tokenizer.eos_token_id,
+                eos_token_id=self._eos_ids,
             )
         return [self.tokenizer.decode(row[input_length:], skip_special_tokens=True) for row in generated]
 
@@ -300,6 +302,29 @@ def _core_missing(missing: Sequence[str]) -> list[str]:
     return [key for key in missing if not any(token in key for token in _IGNORABLE_MISSING)]
 
 
+def _end_of_turn_ids(model: Any, tokenizer: Any) -> list[int]:
+    """Every token that legitimately ends an assistant turn.
+
+    Chat checkpoints ship two of them: `<|im_end|>` closes the message, while the
+    model configuration frequently keeps a pre-training `<|endoftext|>` as the
+    single `eos_token_id`. Stopping on only one of the two makes an otherwise
+    correct answer run to `max_new_tokens` and emit the same call over and over,
+    which the grader then scores as several calls in one turn. The union is what
+    the template actually means, so that is what decoding stops on.
+    """
+    ids: set[int] = set()
+    for source in (
+        getattr(tokenizer, "eos_token_id", None),
+        getattr(getattr(model, "generation_config", None), "eos_token_id", None),
+        getattr(getattr(model, "config", None), "eos_token_id", None),
+    ):
+        if isinstance(source, int):
+            ids.add(source)
+        elif isinstance(source, (list, tuple)):
+            ids.update(int(value) for value in source if isinstance(value, int))
+    return sorted(ids)
+
+
 def _load_model(
     model_id: str,
     dtype: str,