---
license: other
license_name: gpl-3.0-derived-catalogue
license_link: https://huggingface.co/datasets/digitable-lol/digit-router-dataset#8-origin-and-licensing
language:
  - ru
task_categories:
  - text-generation
tags:
  - tool-use
  - function-calling
  - router
  - russian
  - refusal
  - synthetic
size_categories:
  - 10K<n<100K
configs:
  - config_name: default
    data_files:
      - split: train
        path: hf/train.jsonl
      - split: validation
        path: hf/val.jsonl
      - split: full
        path: hf/all.jsonl
---

# digit-router-dataset

**34 709 Russian training rows** for a two-step tool router over a catalogue of
**95 headless utilities** in **14 categories**. Generated deterministically from the
catalogue's JSON schemas — **no teacher model was used**. **23.8 % of the rows are
refusals**, and that fraction is the point of the dataset.

This is the set the published `digitable-lol/digit-router-0.6b` and
`digitable-lol/digit-router-1.7b` adapters were trained on.

---

## 1. Read this first: what this dataset is for, and what it is useless for

The router does not produce the content of an answer. It does two things:

```
query → {"category": "crypto"} → {"tool_id": "hash_text", "args": {"text": "Привет", "algorithm": "SHA256"}}
```

**Step 1** maps a query to one of 14 categories, or refuses. **Step 2**, given the JSON
schemas of that category's tools, emits a tool call with extracted arguments, or refuses.

**It is bound to one specific catalogue of 95 tools.** The tool ids, argument names and
enum values are that catalogue's. Outside it the dataset teaches a model to emit
`{"tool_id": "bip39_from_entropy", ...}` for tools that do not exist in your system.
It is not a general function-calling corpus, and using it as one will produce a model
that confidently routes to nothing. What generalises here is the *method* and the
*refusal design*, not the labels.

Everything else in this card is downstream of that sentence.

## 2. Composition

| | v1 | v2 | **v3 (this release)** |
|---|---:|---:|---:|
| rows | 32 798 | 34 421 | **34 709** |
| unique queries | 18 532 | 18 473 | **18 597** |
| train / validation | 31 186 / 1612 | 32 684 / 1737 | **32 982 / 1727** (5 % by query) |
| tools covered | 94 of 94 | 94 of 94 | **95 of 95** |
| categories | 14 | 14 | 14 |
| queries per tool | median 128 | median 128 | **min 70, median 128** |
| refusal share | 24.4 % | 24.0 % | **23.8 %** (target band 15–25 %) |

*Source: `reports/stats.json` and the producing pipeline's README.*

### By label

| class | rows | share |
|---|---:|---:|
| `tool_call` (routing) | 26 450 | 76.2 % |
| `MISSING_ARGUMENT` | 3422 | 9.9 % |
| `OUT_OF_SCOPE` | 2446 | 7.0 % |
| `FALSE_PREMISE` | 2391 | 6.9 % |
| **refusals total** | **8259** | **23.8 %** |

Step 1 (query → category): 16 791 rows. Step 2 (query + schemas → tool call): 17 918 rows.

### By provenance (`meta.family`)

| family | rows | what |
|---|---:|---|
| `core` | 28 644 | the base classes |
| `domain_fp` | 1780 | `FALSE_PREMISE` about the product, the corpus and technical folklore |
| `decoy_route` | 1343 | step 1 for decoy queries (routing is still required) |
| `decoy_mode` | 1162 | `MISSING_ARGUMENT` with a decoy mode drawn from the schema's enum |
| `decoy_nearmiss` | 1011 | `MISSING_ARGUMENT` with a value of the wrong shape |
| `domain_fp_route` | 769 | step 1 for those false-premise queries that do name a computation |

### The 14 categories

`converter` 5403 · `encoding` 4035 · `crypto` 3500 · `web` 3095 · `text` 2591 ·
`generators` 2649 · `auth` 2156 · `development` 1843 · `math` 1767 · `network` 1677 ·
`data` 1396 · `images` 1027 · `measurement` 761 · `datetime` 465.

## 3. Row format

Every row is a `system` / `user` / `assistant` chat triple plus `meta` for validation.

**Step 1** — the system prompt carries an index of the 14 categories (1447 characters):

```json
{"category": "crypto"}
{"refuse": "OUT_OF_SCOPE"}
```

**Step 2** — the system prompt carries compact schemas for **one** category only
(681–2182 characters; all 95 schemas at once would not fit a sane context for a
0.6B model):

```json
{"tool_id": "hash_text", "args": {"text": "Привет", "algorithm": "MD5"}}
{"refuse": "MISSING_ARGUMENT", "missing": ["text"]}
{"refuse": "FALSE_PREMISE", "correction": "Значения «SHA-999» у аргумента algorithm не существует; допустимые: MD5|SHA1|SHA256|..."}
{"refuse": "OUT_OF_SCOPE"}
```

Schemas render compactly (`text*:string`, `algorithm:enum(MD5|SHA1|…)`); the asterisk
marks a required argument.

Because the schemas are embedded in every step-2 system prompt, **the dataset is
self-contained for training**: you do not need the catalogue file to fine-tune on it.
You do need it to *use* the resulting model.

## 4. Why a quarter of the rows are refusals

A dataset in which every query has an answer teaches one thing above all others:
**that an answer always exists.** A router trained that way will route. It will pick
the closest tool for a request no tool serves, invent an argument that was never given,
and accept a premise that is false — because it has never seen the alternative
demonstrated.

Three refusal classes are therefore first-class labels, not an afterthought:

- **`OUT_OF_SCOPE`** — no tool in the catalogue does this;
- **`MISSING_ARGUMENT`** — the right tool, a required argument absent from the query;
- **`FALSE_PREMISE`** — the query embeds something untrue (a non-existent enum value,
  a non-existent scale, a non-existent property).

The decoy families exist because the naive version of `MISSING_ARGUMENT` is too easy:
`decoy_mode` supplies a plausible mode taken from the tool's own enum while omitting the
argument that actually matters, and `decoy_nearmiss` supplies a value of the wrong shape.
Both make "something was provided" a useless signal.

### The measured effect

Same harness, same 150 red-team tasks, the only change being what the model was trained
on. "Credited" refusals include empty and unparseable output, which the harness scores
as a refusal; "conscious" refusals are explicit `{"refuse": ...}` with a code. The gap
between the two columns is why both are given.

| model | credited refusal | **conscious refusal** | unreadable answers / 250 |
|---|---:|---:|---:|
| bare `Qwen3-0.6B`, no fine-tune | 75.3 % | **9.3 %** | 115 |
| bare `Qwen3-1.7B`, no fine-tune | 81.3 % | **70.7 %** | 21 |
| `Qwen3-0.6B` + this dataset | 91.3 % | **90.7 %** | 2 |
| `Qwen3-1.7B` + this dataset | 91.3 % | **91.3 %** | 1 |

*Source: `train/RESULTS.md` §7, §13.2 of the producing project.*

**Which version was measured.** Those runs used **v2** (34 421 rows). What is published
here is **v3** (34 709). v3 adds no new classes: it resynchronises with a catalogue that
had grown to 95 tools (`emoji_search`, +256 rows — one median tool's worth), removes 28
queries that collided with the held-out evaluation set, and refreshes 21 false-premise
corrections that had gone stale against the live corpus. Adding those rows to the old
file was not possible, because the step-1 category index and the step-2 `text` schemas
both changed, and the file would have ended up with two different system prompts for one
category. No v3-vs-v2 ablation was run, so the numbers above are v2's; treat them as
applying to v3 only to the extent you accept that a 0.8 % row change with no new class
does not move them.

The untuned 0.6B did not refuse — it broke, and the harness credited the wreckage. The
untuned 1.7B genuinely can decline without any fine-tuning, which is worth knowing
before attributing everything to the data.

An independent run on a different harness makes the same point on the same axis: four
bare Qwen3 models over 630 tasks each through vLLM, share of *credited* refusals that
were actual decisions — **2.8 % → 51.5 % → 52.5 % → 64.0 %** for 0.6B → 1.7B → 8B →
32B-AWQ. *Source: `eval/results/BASELINE_VLLM.md`.* Note that this 2.8 % and the 9.3 %
in the table above are **not the same measurement**: different harness, different
denominator, different task mix. Quoting "2.8 % → 91.3 %" as a single before/after would
be crossing two rulers, and this card does not.

### Which lever did the work

Both combinations were measured, so the two can be separated:

| lever | comparison | conscious refusal | tool_accuracy | arg_accuracy |
|---|---|---|---|---|
| **data** (v1 → v2) on 1.7B | 1.7B+v1 → 1.7B+v2 | 83.3 → **91.3** | 86.0 → 85.0 | 92.7 → 90.1 |
| **data** (v1 → v2) on 0.6B | 0.6B+v1 → 0.6B+v2 | 75.3 → **90.7** | 83.0 → 81.0 | 93.7 → 88.9 |
| **base size** (0.6B → 1.7B) on v2 | 0.6B+v2 → 1.7B+v2 | 90.7 → 91.3 | 81.0 → **85.0** | 88.9 → 90.1 |

Tripling the base model buys 4 points of routing accuracy and 0.6 points of conscious
refusal. Changing the dataset buys 8–15 points of conscious refusal on either base.
**The data did the work.** Note the cost, stated in the same table: argument accuracy
went *down* 3–5 points on both bases. Teaching a model to decline makes it slightly
worse at filling in the cases where it does not decline, and that trade is not free.

## 5. How the queries are built

Phrasings are not written one at a time. Each of the 95 tools has lexical seeds
substituted into grammatically safe frames — imperatives ("посчитай хеш"), infinitives
("посчитать хеш"), noun phrases ("хеш строки") — with typo, casing and politeness noise
layered on. The generator is deterministic under `seed = 20260802`, so the file
regenerates byte-for-byte.

This is the dataset's other big limitation, and §7 says what it costs.

## 6. Validation

`reports/validation.json` is the gate the generator must pass:

| check | result |
|---|---|
| structural errors | **0** |
| rows / unique queries | 34 709 / 18 597 |
| refusal share within the 15–25 % band | **true** (23.8 %) |
| tools covered | **95 of 95** |
| train/validation leakage | **0** |
| verbatim overlap with the evaluation sets | **0** |
| near-duplicate overlap (Jaccard ≥ 0.7) with the evaluation sets | **0** |
| red-team span overlap | **0** |

Two categories of near-overlap are reported rather than suppressed, because "zero
overlap" is a claim that deserves its exceptions in writing:

- **8 rows share a ≥ 6-word span with a main-set evaluation query.** They are literal
  payloads a user would paste — a `docker run` line, a User-Agent string, a SQL
  statement, `192.168.1.0/24`. The requests around them differ; the shared span is the
  data, not the task.
- **6 red-team evaluation queries are contained inside a longer training query**, of
  which 5 belong to the published set and are listed in `reports/validation.json`; the
  sixth belonged to the held-out set and its entry was removed along with everything
  else naming that set. "переведи в base64" (a `missing_param` task) is a prefix of
  "ДАВАЙ переведи в base64 The quick brown fox" — a complete request with the argument
  present. The eval task is a refusal case precisely because the tail is absent.

During generation, 186 candidate rows were rejected for colliding with an evaluation
task, and 4607 more were dropped for containing an unjustified required argument.

## 7. Limits — read before using

1. **Bound to one catalogue.** Repeated because it is the one that ends most attempts to
   reuse this: 95 specific tool ids, their argument names and their enum values. Outside
   that catalogue the labels are wrong, not merely unhelpful.

2. **Templated phrasing.** Queries are generated from seeds and frames, not collected
   from users. Indirect, conversational and elliptical phrasing is under-represented.
   This is a known and measured gap, which is what
   `digitable-lol/hard-negatives-ru` (config `paraphrases`, 2967 rows) exists to patch —
   and the fact that a patch was needed is the honest summary of this limitation.

3. **Russian only.** Argument *values* are frequently English or symbolic (the
   `emoji_search` tool searches by English keyword, so its arguments are English by
   necessity), but every request frame is Russian.

4. **No teacher, therefore no teacher's judgement.** The labels are correct by
   construction relative to the catalogue schemas. They contain no notion of what a
   person would actually have meant. A control measurement from the paraphrase work is
   worth knowing: a 32B teacher shown these rows reproduces the dataset's own label for
   only **64.6 %** of them. That is not evidence the labels are wrong — the teacher is
   the less reliable of the two here — but it is evidence that "obviously correct" is
   doing work in that sentence.

5. **`refusal_share` is a design parameter, not a discovered fact.** The 15–25 % band
   was chosen, and the generator was tuned to it. If your deployment's real
   out-of-scope rate is 60 %, this mixture is wrong for you.

6. **The evaluation sets are not in here.** Overlap checks were run against both the
   published `digitable-lol/digit-eval-tasks` and a held-out set that is deliberately
   not published. Entries in `reports/` that named tasks from the held-out set have been
   removed, with the removal recorded in the file.

7. **`meta.mentions` and `meta.extracted` are generator bookkeeping.** They are shipped
   because dropping them would make the rows unverifiable, not because they are a
   documented interface.

## 8. Origin and licensing

**The metadata licence is `other`, deliberately.**

The tool descriptions, tool ids, argument names, enum values and schema shapes in this
corpus are derived from the project's `tools-core` catalogue, which is **GPL-3.0,
inherited from [`it-tools`](https://github.com/CorentinTh/it-tools)**. Query phrasings,
refusal classes, false-premise corrections and the generation method are the project's
own.

Whether a copyleft licence on a source catalogue propagates to a dataset generated from
its schemas, or to models trained on that dataset, is an **unsettled question**, and this
repository does not pretend to settle it. We state the provenance and decline to declare
the dataset GPL-3.0. If your compliance posture requires a definite answer, treat the
GPL-3.0 provenance of the catalogue as a fact you must evaluate. This paragraph is not
legal advice and not a grant.

Neither `gpl-3.0` nor any permissive tag would be an honest single-token summary, which
is why the field says `other`.

The same reasoning, and the same wording, was applied to the model repositories trained
on this data.

## 9. Files and loading

| path | what |
|---|---|
| `data/all.jsonl` | all 34 709 rows, canonical, byte-identical to what trained the models |
| `data/train.jsonl` | 32 982 rows |
| `data/val.jsonl` | 1727 rows (5 % split by query, so no query straddles the split) |
| `hf/*.jsonl` | the same rows with an Arrow-friendly schema |
| `reports/stats.json` | full composition: per-tool counts, per-category counts, decoy counts |
| `reports/validation.json` | the validation gate's output |
| `MANIFEST.json` | sha256 of every published file |

```python
from datasets import load_dataset
ds = load_dataset("digitable-lol/digit-router-dataset")
ds["train"], ds["validation"], ds["full"]
```

**Why there are two copies.** `meta` is a free-form object whose `args` key differs in
shape and type per tool. On `datasets` ≥ 5 that is fine — the library types the column
as `Json` and hands back a plain dict — and
`load_dataset("json", data_files="data/all.jsonl")` was tested and works. Earlier
versions infer an Arrow struct from a sample of rows and fail on the union. The `hf/`
view avoids the question entirely: it carries `meta_json` (the original object as a JSON
string, `json.loads` round-trips it exactly) alongside lifted scalar columns `step`,
`label`, `tool_id`, `category`, `family`, plus `query` and `target` pulled out of
`messages` so you can filter without parsing. The system prompt is deliberately *not*
duplicated into its own column — it is 0.7–2.2 kB per row and copying it would double
the published size; read it from `messages[0]`. Train on `data/`; slice with `hf/`.

## 10. Reproduction

```bash
python3 src/build_tracks.py
python3 src/generate.py --per-tool 128 --missing-per-tool 14 --oos 1600 \
                        --fp-enum 750 --decoy-per-tool 14 --domain-fp 1400
python3 src/validate.py          # must return PASS
```

The generator is deterministic under `seed = 20260802`. Regenerating requires the
`tools-core` catalogue at the same revision; the catalogue is live, and this release
corresponds to the 95-tool state of it.

---

## По-русски, коротко

**Что это.** 34 709 строк на русском для двухшагового маршрутизатора к каталогу из
**95 утилит** и 14 категорий. Построено **детерминированно из JSON-схем каталога,
teacher-модель не использовалась**. Парафразы — отдельный файл в
`digitable-lol/hard-negatives-ru`.

**Отказы — 23.8 %.** Три класса: `OUT_OF_SCOPE`, `MISSING_ARGUMENT`, `FALSE_PREMISE`.
Зачем: без них модель выучивает, что **ответ существует всегда**, и начинает
маршрутизировать туда, где утилиты нет, и подставлять аргумент, которого не было.

**Измеренный эффект.** Один и тот же харнесс, 150 red-team задач: осознанный отказ
**9.3 % → 90.7 %** (0.6B без тюна → 0.6B на этих данных) и **70.7 % → 91.3 %** для 1.7B.
Основную работу сделали данные, а не размер базы: смена базы даёт +0.6 п.п. осознанного
отказа, смена датасета — +8…15 п.п. Цена названа там же: точность аргументов падает на
3–5 п.п.

**Применим только с нашим каталогом** из 95 утилит. Вне его ids, имена аргументов и
enum-значения просто неверны — это не общий корпус function-calling.

**Происхождение.** Описания и схемы инструментов производны от каталога
[`it-tools`](https://github.com/CorentinTh/it-tools) под **GPL-3.0**. Вопрос о
распространении copyleft на производные данные в отрасли не решён: мы указываем
происхождение и не объявляем датасет GPL-3.0. Поле лицензии — `other`, сознательно.