--- license: apache-2.0 pretty_name: PhoneToolBench language: - en - pt - es - de task_categories: - text-generation tags: - tool-use - function-calling - phone-assistant - reasoning - benchmark size_categories: - n<1K configs: - config_name: default data_files: - split: test path: data/test.jsonl --- # PhoneToolBench A held-out benchmark for **phone tool calling**, built on the exact tool catalog and scoring rules of the [LiquidAI phone-assistant tools dataset](https://huggingface.co/datasets/LiquidAI/phone-assistant-tools). It is meant for small reasoning models (roughly 1B to 8B parameters) that emit `` blocks and support tool calling. Use it to measure how much a model improved after fine-tuning on the phone tool set, compared with its base model. - **520 items**, 130 per language (English, Portuguese, Spanish, German). - **108 tools**, the full phone catalog. Every item is shown the whole catalog, as in training. - **66 items use 10 held-out tools** that never appear in the training or test splits (see below). - Gold answers are exact tool-call lists. Scoring is deterministic: no LLM judge. ## Why it is hard - **Lookalike pairs.** 71 items ask for an action where a near-duplicate tool exists in the catalog (for example a stopwatch versus a timer), so the model must pick the right one. - **Reasoning items** (123) need arithmetic, unit or currency conversion, or date and duration arithmetic from the context timestamp before the arguments are correct. - **Multi-call items** (79) need two or three calls in one turn. - **Partial items** (38) are only partly possible. The right answer calls the possible tool and says what it cannot do. - **Abstention items** (86) need no tool. Of these, 41 need no tool at all and 45 need a clarifying question because a required detail is missing. A model that always calls a tool scores poorly here. - **Held-out tools** (66 items) test generalization to tools the model has not seen in training. Requests are generated from templates, so the phrasing is more regular than real user speech. See *Limitations*. ## Data format `data/test.jsonl`, one JSON object per line: | field | type | meaning | |---|---|---| | `id` | str | `ptb-0000` … `ptb-0519` | | `language` | str | `en`, `pt`, `es`, `de` | | `category` | str | `single`, `multi`, `reasoning`, `lookalike`, `partial`, `no_tool`, `clarify` | | `subtype` | str or null | for `reasoning`: the kind of arithmetic needed, e.g. `duration+date`, `currency`, `unit+arithmetic` | | `tool_split` | str | `seen` (all gold tools appear in training) or `heldout` (at least one gold tool is held out) | | `gold_tools` | list[str] | names of the tools in the gold calls (for reporting only; the model is not shown this list) | | `context` | dict | `datetime` (local, ISO 8601), `timezone` (IANA), `locale` | | `request` | str | the user's message | | `calls` | str | JSON list of gold calls `{"name": ..., "arguments": {...}}` | Gold calls use the same format as the training data. Gold call counts: 86 items with 0 calls, 306 with 1, 99 with 2, 29 with 3. ### Held-out tools These tools never appear in the training or test splits of the source dataset: `append_to_note`, `control_smart_plug`, `draft_email`, `get_air_quality`, `get_ride_estimate`, `request_money`, `search_hotels`, `set_hotspot`, `set_sleep_timer`, `share_location` ## Protocol 1. Build each prompt with the system prompt from `phonebench/prompt.py`. It is copied verbatim from the training notebook, with the date, time, timezone and locale filled in from `context`. 2. Pass the **full 108-tool catalog** (`tools.json`) as the tool list, through the model's chat template. Do not pass `gold_tools`. 3. Turn on the model's reasoning mode (`--thinking on`) for reasoning models. Decode greedily (temperature 0). 4. Parse the answer. Thinking is split at ``, and tool calls are read from Hermes `` JSON or from a pythonic list (`[name(arg=value)]`). A server that returns structured `tool_calls` (vLLM, llama.cpp, Ollama) is scored directly. 5. Score each item against its gold calls. ### Scoring - **Exact match**: the predicted call list equals the gold list. Call order does not matter. Each argument is compared according to its kind from `scoring.json`: `expr` (arithmetic is evaluated and compared), `datetime`, `date` and `time` (parsed and compared), `name` (case and accent insensitive), `text` (similarity), `code` (punctuation and spacing ignored), `enum` (case insensitive), and `bool`, `int` and `number` (compared by value). - **Micro exact match**: mean over all 520 items. - **Macro exact match**: mean of the per-category accuracies. This is the headline number, because the categories are unequal in size. - **Tool-name F1**: how well the set of predicted tool names matches the gold set. - **False-call rate** on no-call items (`no_tool`, `clarify`): lower is better. - **Schema error rate** on predicted calls: calls that break the tool's argument schema. - **Parse error rate** and **truncation rate**: output that could not be read, or hit the token limit. - Breakdowns by category, reasoning subtype, language, and seen versus held-out tools. Reference points: the oracle (gold answers) scores 100%. A model that never calls a tool scores 16.5% exact match (it gets every no-call item right and nothing else). ## Using the harness The repo ships the benchmark data, the scorer, and a runner. ```bash pip install -r requirements.txt # harness sanity checks (should print 100% and 16.5%) python -m phonebench.run --backend oracle --name oracle python -m phonebench.run --backend no_call --name no_call # local Hugging Face model, reasoning on (needs a GPU for models this size) python -m phonebench.run --backend hf --model --thinking on --batch-size 8 # any OpenAI-compatible server (vLLM, llama.cpp server, Ollama, LM Studio) python -m phonebench.run --backend openai --base-url http://localhost:8000/v1 --model --thinking on # quick check on the first 50 items python -m phonebench.run --backend hf --model --limit 50 ``` Each run writes `results//records.jsonl` (one record per item, with predicted and gold calls and the raw output), `summary.json`, and `summary.md`. Serving the model through a server with its own tool-call parser is the most reliable route for models whose tool-call format is not Hermes or pythonic. Otherwise the parser can count valid calls as parse errors. If the chat template does not receive `tools`, the model cannot know the catalog and the score will mostly reflect that. Check `summary.md` for parse and schema errors before trusting a number. To compare fine-tuned and base models, run both with identical settings (same `--thinking`, `--max-new-tokens`, and decoding) and compare macro exact match, the seen versus held-out split, and the false-call rate. ### Tests and validation ```bash python scripts/validate.py # schema, self-match, uniqueness, catalog coverage python -m unittest discover -s tests -v # parser, scorer, prompt and data tests ``` ### Rebuilding the data `scripts/build_bench.py` regenerates the benchmark deterministically (seed `20260314`) from the source dataset: ```bash python scripts/build_bench.py --hub LiquidAI/phone-assistant-tools --out data/test.jsonl --items 520 --seed 20260314 ``` It also checks every item against the tool schema, rejects requests that duplicate training or test text after normalization, and verifies that gold answers match themselves. ## Files ``` README.md this dataset card data/test.jsonl the benchmark (520 items) tools.json phone tool catalog (108 tools), from LiquidAI, Apache-2.0 scoring.json argument kinds for scoring, from LiquidAI, Apache-2.0 phonebench/ scorer, prompt, parser, backends, runner scripts/build_bench.py deterministic generator scripts/validate.py integrity checks tests/test_harness.py unit tests requirements.txt ``` ## Limitations - **Template phrasing.** Requests are generated from templates in four languages. They are less varied than real user speech, and a score here does not guarantee the same score on real requests. - **Four languages.** The source training data covers 16. Only en, pt, es and de are included here. - **Catalog coverage.** The benchmark uses the 108 tools of the source catalog. Tools outside that catalog are not tested. - **Thinking format.** The parser splits `` blocks and reads Hermes or pythonic calls. Other formats need a server-side parser, as described above. - **Single turn.** Each item is one user message. Multi-turn follow-ups, such as answering a clarifying question, are not tested. - **Status.** The harness is unit-tested, and the oracle and no-call baselines have been run. No model scores have been published with this release. ## Attribution The tool catalog, argument kinds, and training-style prompt come from [LiquidAI/phone-assistant-tools](https://huggingface.co/datasets/LiquidAI/phone-assistant-tools), licensed Apache-2.0. The benchmark items, generator and harness are released under the same license.