File size: 4,276 Bytes
d9a3a96 fb80a30 d9a3a96 fb80a30 51664b0 fb80a30 51664b0 fb80a30 51664b0 fb80a30 51664b0 fb80a30 51664b0 fb80a30 51664b0 fb80a30 51664b0 fb80a30 51664b0 fb80a30 51664b0 fb80a30 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | ---
license: cc-by-nc-4.0
language:
- en
tags:
- tool-use
- function-calling
- agent-evaluation
- llm-evaluation
pretty_name: Tool Selection Quality Benchmark
dataset_info:
features:
- name: tools_list
dtype: string
- name: messages_history
dtype: string
- name: binary_label
dtype: string
- name: label
dtype: string
- name: failure_reason
dtype: string
splits:
- name: test
num_bytes: 39125340
num_examples: 5000
download_size: 9922540
dataset_size: 39125340
configs:
- config_name: default
data_files:
- split: test
path: data/test-*
---
# Tool Selection Quality Benchmark
A benchmark for evaluating whether an LLM correctly judges the quality of a
**tool call / function call** made by another model - i.e. given a user
request, the tools available, and the model's resulting function call (or
direct reply), did the model pick the right tool and fill it in correctly?
Each row is one turn to be judged: a message history ending in either a
function call or a direct assistant response, paired with the set of tools
that were available, and a ground-truth verdict on whether that call was
correct and, if not, what specifically went wrong.
## Dataset Structure
| Column | Type | Description |
|---|---|---|
| `tools_list` | string | Stringified list of the tool/function definitions (name, description, JSON-schema parameters) available to the model for this turn. |
| `messages_history` | string | The conversation up to and including the model's response: the user's request and either a `function_call` (tool name + arguments) or a direct assistant reply. |
| `label` | string | Ground-truth verdict - one of `VALID_CALL`, `TOOL_ERROR`, `PARAM_NAME_ERROR`, `PARAM_VALUE_ERROR` (see taxonomy below). |
| `binary_label` | string | Collapsed verdict: `CORRECT` (`VALID_CALL`) or `INCORRECT` (any of the three error labels). |
| `failure_reason` | string | Short free-text reason for the failure (e.g. `"incorrect tool selected"`, `"hallucinated parameter name"`), or `"None"` when `label` is `VALID_CALL`. |
### Example row
A user asks Cribl to fetch a pipeline's config; the model correctly calls
`cribl_getPipelineConfig` with the right `pipelineId`/`groupName` arguments →
`label: VALID_CALL`, `binary_label: CORRECT`, `failure_reason: None`.
## Label Taxonomy
Verdicts follow a strict, ordered check - tool selection first, then
parameter structure, then parameter values - and the first failing check
determines the label:
1. **Tool Selection** - does the chosen tool exist and match the user's
intent? If not → `TOOL_ERROR` (e.g. wrong tool picked, or a tool call made
when none was needed, or vice versa).
2. **Parameter Structure** - are the required parameter names present, and
are there no extraneous/hallucinated ones? If not → `PARAM_NAME_ERROR`.
3. **Parameter Values** - are the parameter values correctly typed,
formatted, and factually consistent with the request? If not →
`PARAM_VALUE_ERROR`.
If none of these trigger - including the case where the user's request needed
no tool call at all and the model correctly replied directly - the turn is
`VALID_CALL`.
## Dataset Statistics
- **5,000 rows total.**
`label` distribution:
| Label | Count |
|---|---|
| VALID_CALL | 2,000 |
| TOOL_ERROR | 1,000 |
| PARAM_NAME_ERROR | 1,000 |
| PARAM_VALUE_ERROR | 1,000 |
`binary_label` distribution:
| Label | Count |
|---|---|
| CORRECT | 2,000 |
| INCORRECT | 3,000 |
## Usage
```python
from datasets import load_dataset
ds = load_dataset("qualifire/tool-selection-quality-benchmark")["test"]
print(ds[0])
```
A common evaluation pattern is to score a judge model on each row (given
`tools_list` + `messages_history`) and compare its predicted label - or the
collapsed `binary_label` - against ground truth, both overall and broken
down per label.
## Considerations for Use
- This benchmark is intended for evaluating **tool-use/function-calling
judge models** - i.e. models whose job is to critique another model's tool
call, not models that make tool calls themselves.
- Labels reflect a specific, ordered evaluation rubric (tool → parameter
names → parameter values); treat them as a strong baseline rather than an
unimpeachable gold standard.
|