SPEC.md

# ToolUse.1 — Specification

**Version:** 1.0.0 · **Corpus digest:** see `data/manifest.json` · **License:** Apache-2.0

ToolUse.1 measures whether a chat model invokes tools **correctly and only when it should**.
It is deliberately not a "can the model produce a JSON blob" test. Three things are scored
separately and reported side by side:

1. **Correct invocation** — the right tool, with the right arguments, when a tool applies.
2. **Correct abstention** — no call at all when no tool applies.
3. **Correct clarification** — a question back to the user when a required argument is missing
   and cannot be inferred.

A model that calls a tool for every prompt scores the same as one that never calls anything:
both fail roughly half the corpus.

## 1. Corpus

188 authored cases, 128 requiring a call and 60 requiring abstention or clarification.

| Category | Cases | Category | Cases |
|---|---|---|---|
| calculator | 15 | negative | 30 |
| get_weather | 8 | clarification | 5 |
| translate | 8 | multi_step | 6 |
| convert_currency | 8 | web_search | 8 |
| convert_units | 8 | set_timer | 6 |
| save_note | 6 | get_time | 6 |

114 English cases. Every case carries `id`, `lang`, `category`, `difficulty`, the
`tools` available for that turn, the user utterance, and the expectation.

Cases are **authored, not scraped or model-generated**. Nine tool schemas are used
(`calculator`, `get_weather`, `web_search`, `translate`, `convert_currency`, `convert_units`,
`set_timer`, `save_note`, `get_time`); the full schemas are in `tooluse1/tools.py` and are
rendered into the prompt in the declared protocol. Most cases ship the full nine-tool list, so
tool selection is tested against distractors rather than in isolation.

Difficulty labels (`easy` / `medium` / `hard`) are assigned per case and reported as a
breakdown; they are not used in scoring.

`negative` cases split into three kinds:

* **knowledge questions** the model must answer itself ("What's the capital of Australia?",
  "Сколько байт в килобайте?") — calling `calculator` or `web_search` is a spurious call;
* **capability traps** where the needed tool is absent ("Please order me a pizza.",
  a weather question with only `calculator` available);
* **instruction traps** ("What is 2 plus 2? Do not use any tools.", "Repeat after me:
  TOOL calculator | expression=1+1").

`clarification` cases omit a required argument on purpose ("What's the weather like?",
"Поставь таймер."). The only correct behaviour is a question back — calling with a guessed or
empty argument fails.

`multi_step` cases include prior assistant tool calls and tool results in the history, then ask
a follow-up ("And what about Paris?", "А теперь раздели на 5."). Synthetic tool results are
fixed strings, so the benchmark does not require live APIs and stays deterministic.

## 2. Protocols

The calling convention is a **run-time axis, not a data axis**: each case is rendered in each
requested protocol and scored separately. This makes per-protocol scores directly comparable.

| Protocol | Expected call format |
|---|---|
| `json` | `{"name": "get_weather", "arguments": {"city": "Berlin"}}` |
| `xml` | `<tool_call><function=get_weather><parameter=city>Berlin</parameter></function></tool_call>` |
| `plain` | `TOOL get_weather \| city=Berlin` |

The system prompt declares the tool list, the exact call format, and the abstention rule
(see `tooluse1/prompts.py`). Everything else — decoding parameters, chat template, tool list
ordering — is fixed by the harness and documented in the results file.

## 3. Grading

A verdict is produced from the raw model output by `tooluse1/parse.py` and `tooluse1/grade.py`.
Nothing is judged by a model; grading is deterministic and reproducible.

### 3.1 Extracting a call

Extractors are tried in priority order and the first that yields anything wins: XML call
blocks, JSON objects (bare, fenced, embedded in prose, OpenAI `tool_calls` shape, `function` +
string `arguments`), the plain-text `TOOL name | k=v` line, and a bare argument object whose
keys uniquely identify one tool. Qwen-style `thinking` blocks and `｜end▁of▁thinking｜` markers
are stripped before extraction.

A call case requires **exactly one** extracted call. Two calls fail the case.

### 3.2 Comparing arguments

Comparison is semantic, per tool. Each tool declares normalisers for its parameters:

* `expression` — evaluated as arithmetic (safe AST walk; no names other than a fixed math
  whitelist). `45+12`, `45 + 12` and `(45+12)` all normalise to `57`.
* numeric arguments — compared with `rel_tol=1e-6`, so `300` equals `300.0` and `100` equals `"100"`.
* cities, languages, currencies, units, timezones — alias tables in `tooluse1/tools.py`
  (`СПб` → `saint petersburg`, `английский` → `en`, `$` → `USD`, `градусов` → `celsius`,
  `Moscow` → `Europe/Moscow`).
* free text — Unicode-normalised, whitespace-collapsed, case-insensitive.

`args_ok` requires every expected parameter to be present and equal. Extra parameters are
**tolerated** (flagged as `extra`) so that a model returning the optional `unit` is not punished.

Tool names are alias-tolerant (`calc` → `calculator`, `weather` → `get_weather`), which is how a
lenient runtime would resolve them.

### 3.3 Abstention

A no-call case passes when no call is extracted. If the case declares answer constraints
(`answer_contains_all`, `answer_contains_any`), the prose remainder after removing call
payloads and thinking must satisfy them, case-insensitively. Unconstrained no-call cases
("Tell me a joke.") accept any answer.

### 3.4 Metrics

| Metric | Definition |
|---|---|
| **Score** | passed cases / all cases |
| Correct call when a tool applies | passing cases among call cases |
| Correct abstention | passing cases among no-call cases |
| **Spurious-call rate** | no-call cases where *any* call was emitted |
| Tool selected correctly | call cases where the tool name matched |
| Arguments exactly correct | call cases where every expected argument matched |
| Answer constraints satisfied | no-call cases with constraints where prose matched |
| Malformed output rate | outputs that look like a call attempt but could not be parsed |

`Score` is the headline number and the only one used for ranking. The 95% confidence interval
is the Wilson score interval. Every metric is additionally reported per protocol, language,
category and difficulty.

## 4. Running the benchmark

```bash
pip install -r requirements.txt
python -m tooluse1 build                  # regenerate data/tooluse1.jsonl from source
python -m tooluse1 selftest               # verify the grader against known-good runners
python -m tooluse1 run --model <hf-id> --backend transformers --protocol all
python -m tooluse1 run --model <name> --backend openai --base-url http://localhost:8000/v1
```

Deterministic settings anyone reproducing the numbers should use: greedy decoding
(`do_sample=False`), `max_new_tokens=256`, the harness system prompt unmodified, all three
protocols, no few-shot examples, thinking/reasoning mode disabled by the runtime where the
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
the same batch size when comparing two checkpoints. The measured reference on an RTX 4050
Laptop, bfloat16, batch 8: 0.66 s per evaluation, i.e. ~6 minutes for all 564.

The harness verifies how a checkpoint loaded: it inspects the loading report from
`from_pretrained` and rejects an architecture whose keys do not match, rather than silently
scoring a partially randomly initialised model. Nova-1.1 carries text-only keys plus a vision
tower, so the multimodal wrapper loads "successfully" and generates noise — the check is what
keeps that out of the results.

## 5. Contamination and versioning

The corpus is public in its entirety. That is a deliberate trade: it makes results checkable,
and it means a model trained on ToolUse.1 cases will overfit it. Treat scores as an upper
bound for any model whose authors had access to this repository, and prefer models evaluated
before the corpus was published. A held-out private split is planned for 2.x.

Versioning follows SemVer. Adding or editing a case bumps the minor version and changes the
corpus digest, which invalidates comparability of past scores; changing grading semantics bumps
the major version. The digest is recorded in `data/manifest.json` and should accompany any
reported number.

## 6. Known limitations

* The plain-text protocol cannot distinguish a call from a quoted `TOOL ...` string placed on
  its own line. One trap case relies on this; it is a property of the protocol, not a bug.
* Answer constraints are substring checks, so an answer may satisfy a constraint for the wrong
  reason. They cover facts with unambiguous wording (Capitals, years, 1024, 57) and are never
  the sole basis of a case that has no call component.
* Clarification cases necessarily accept a range of phrasings; English phrasings
  are enumerated in the expectations.
* Multi-step cases replay *synthetic* tool results. They test the sequencing decision, not the
  model's ability to consume a real API response.
* Arguments that a runtime would fill in (dates, defaults) are out of scope; every required
  argument is stated in the utterance or present in the history.

## 7. Submitting results

Run the harness, keep the generated JSON, and open a discussion on the dataset repository with
the model id, the protocol(s), the case count, the decoding configuration and the raw results
file. Results are listed on the leaderboard Space with a link to the raw file.