---
license: other
language:
- en
task_categories:
- text-generation
tags:
- tool-calling
- function-calling
- in-vehicle
- voice-assistant
- agentic
- synthetic
pretty_name: Nova In-Vehicle Assistant Tool-Calls v0.2
size_categories:
- 10K<n<100K
dataset_info:
  features:
  - name: messages
    list:
    - name: role
      dtype: string
    - name: content
      dtype: string
    - name: tool_calls
      list:
      - name: id
        dtype: string
      - name: type
        dtype: string
      - name: function
        struct:
        - name: name
          dtype: string
        - name: arguments
          dtype: string
    - name: name
      dtype: string
  - name: tools
    dtype: string
  - name: _source_file
    dtype: string
  - name: _intent
    dtype: string
  - name: _tier
    dtype: string
  - name: _augmentation
    dtype: string
  splits:
  - name: train
    num_bytes: 444950615
    num_examples: 43087
  download_size: 5188599
  dataset_size: 444950615
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
---

# Nova IVA Tool-Calls v0.2

**Nova IVA Tool-Calls** is a synthetic English **text** dataset for building and
studying **in-vehicle voice-assistant tool use**: mapping natural driver
utterances to structured, schema-valid function/tool calls. It spans single-turn
commands, multi-turn slot-filling / correction dialogues, and the
call-vs-refuse-vs-clarify-vs-answer decision boundary, plus a held-out
novel-tool split for measuring **zero-shot tool generalization**.

Each example is an OpenAI-format conversation (`messages`) paired with the
in-context tool schemas (`tools`) it is evaluated against; positive examples
carry the gold `tool_calls`. Tool schemas travel *inline per row*, so the task
is "read the toolbox in context and match arguments to it," not intent->tool
memorization.

- **Rows:** 43,087  (+ 65 held-out novel-tool rows)
- **Tool-call examples:** 35,250  ·  **No-call examples** (refuse / clarify / direct / negative): 7,837
- **Intents:** 25 (23 tool-bearing + 2 info-only) across 6 domains — `vehicle_control`, `navigation`, `connected`, `entertainment`, `driver_state`, plus `false_positive`
- **Tools:** 30 canonical in-domain function schemas (action-dispatched) + flat MCP-style novel tools
- **Language / format:** English · JSON Lines (OpenAI `messages` + `tools`)

<img src="figures/capability_mix.png" alt="Capability mix" width="60%"/>

## At a glance

| Subset | Description | Rows |
|---|---|---|
| `dialogues_T6` | Correction — mid-dialogue value revision; final call uses corrected slots | 11,295 |
| `dialogues_T7` | Conversation — multi-turn slot-filling ending in a tool_call | 11,075 |
| `dialogues_T3` | Multi-intent — 2-3 intents in one utterance, one tool_call each | 10,877 |
| `negatives` | Hard negatives — disambiguation + hallucination-resistance | 2,389 |
| `single_turn_calls` | Single-turn command -> schema-valid tool_call | 2,113 |
| `refusals` | Refusal — out-of-scope request declined, no tool_call | 1,796 |
| `clarifications` | Clarification — assistant asks for a missing required slot | 1,445 |
| `direct` | Direct answer — general question answered without a tool_call | 773 |
| `single_turn` | False-positive — chit-chat / rhetorical, correctly no tool_call | 677 |
| `tool_gen` | Tool generalization — novel / MCP-style tools, schema-matched args | 647 |

<img src="figures/rows_by_source.png" alt="Rows by source" width="60%"/>

## Complexity tiers

Examples are stratified by an 8-tier complexity scheme adapted from
**Audio2Tool** [[1]](#references) (tier 8 is acoustic and out of scope for this
text dataset). The call-vs-refuse-vs-clarify-vs-answer decision boundary
(subsets *refusals*, *clarifications*, *direct*, *false-positive*) follows
**When2Call** [[2]](#references), and the multi-turn in-vehicle dialogue
structure of tiers T6/T7 follows Du et al. [[3]](#references):

| Tier | Description | Source |
|---|---|---|
| T1 Direct | 2-6 word imperative commands | [[1]](#references) |
| T2 Parametric | commands with explicit parameter values | [[1]](#references) |
| T3 Multi-intent | 2-3 intents combined in one utterance | [[1]](#references) |
| T4 Implicit | state / complaint phrasing ("it's hot in here") | [[1]](#references) |
| T5 Needle | intent buried in unrelated rambling speech | [[1]](#references) |
| T6 Correction | mid-dialogue self-correction of a slot value | [[1]](#references), [[3]](#references) |
| T7 Conversation | multi-turn user <-> agent slot-filling | [[1]](#references), [[3]](#references) |
| T8 Acoustic | foreground/background audio blending (not included) | [[1]](#references) |

## Dataset structure

One row per conversation. Fields:

| Field | Type | Description |
|---|---|---|
| `messages` | list[object] | OpenAI-format turns: `system`, `user`, `assistant`. Positive rows include an `assistant` message with `tool_calls` (`function.name`, `function.arguments` as a JSON string). |
| `tools` | string (JSON) | The in-context tool schemas for this row (OpenAI function format), stored as a JSON-encoded string (tool parameter schemas are heterogeneous, so they are serialized for a stable column type). Parse with `json.loads`. Empty list `[]` for direct-answer / empty-toolbox refusal rows. |
| `_source_file` | string | Originating generation stage (see *At a glance*). |
| `_intent` | string | Ground-truth intent name (e.g. `vehicle_control.set_temperature`), when applicable. |
| `_tier` | string | Complexity tier (T1-T7), for stratified analysis. |
| `_augmentation` | string | `original`, `paraphrase`, or `substitution:<slot>=<value>`. |

Tool-call arguments are validated against a formal per-action JSON Schema; the
`tools.json` file at the repository root lists the 30
canonical in-domain tools. Vehicle controls share one `vehicle_command` tool
dispatched by an `action` field; other domains use dedicated tools.

### Tool distribution (top 12)

<img src="figures/tool_distribution.png" alt="Tool distribution" width="60%"/>

| Tool | tool_call count |
|---|---|
| `vehicle_command` | 15,088 |
| `media_command` | 7,254 |
| `telephony_command` | 7,049 |
| `geocode` | 6,497 |
| `traffic_query` | 3,046 |
| `routing` | 2,833 |
| `vehicle_query` | 2,524 |
| `reminder_command` | 2,394 |
| `connectivity_command` | 2,290 |
| `calendar_query` | 1,865 |
| `web_search` | 1,533 |
| `driver_assist` | 1,507 |

### Conversation length

<img src="figures/turn_distribution.png" alt="Turn distribution" width="60%"/>

## Usage

```python
from datasets import load_dataset
import json

ds = load_dataset("Senthi1Kumar/nova-iva-toolcalls-v0.2", split="train")
row = ds[0]

for m in row["messages"]:
    print(m["role"], "->", (m.get("content") or "")[:80])
    for tc in (m.get("tool_calls") or []):
        fn = tc["function"]
        print("   tool_call:", fn["name"], json.loads(fn["arguments"]))

# The in-context toolbox this row is matched against. `tools` is a JSON
# string; refusal / direct-answer rows carry an empty toolbox ("[]"), so
# guard before parsing.
tools = json.loads(row["tools"]) if row["tools"] else []
print("tools:", [t["function"]["name"] for t in tools])
```

## How the data was generated

Examples are produced by a multi-stage synthesis pipeline. A hand-authored
canonical intent schema (25 intents) is the single source of truth; every
generation stage reads tool names, actions, and argument schemas through one
contract layer that fails fast on drift. Generated tool-calls are validated
against a per-action JSON Schema **reject-loop** — the argument names, types,
enums, and numeric bounds must all satisfy the schema or the row is dropped.
Persona paraphrase and slot-value substitution — following the CTFusion
augmentation pattern [[5]](#references) — augment surface diversity while
preserving the gold tool-call. Multi-turn positive tiers are gated to a
>60% tool-call rate; the final set is 99.9% schema-clean on tool names.

- **Generator model:** `deepseek/deepseek-v4-flash`
- **Approx. generation cost:** ~$30.00 USD
- **Held-out split:** a set of novel MCP-style tools (65 rows)
  is withheld entirely from training for zero-shot tool-use evaluation.

## References

This dataset's design draws on the following work:

1. **Audio2Tool** — Ramit Pahwa, Apoorva Beedu, Parivesh Priye, Rutu Gandhi,
   Saloni Takawale, Aruna Baijal, and Zengli Yang. 2026. *Audio2Tool: Speak,
   Call, Act — A Dataset for Benchmarking Speech Tool Use.* Rivian & Volkswagen
   Technologies. <https://audio2tool.github.io/> (8-tier speech-to-tool
   complexity scheme.)
2. **When2Call** — Hayley Ross, Ameya Sunil Mahabaleshwarkar, and Yoshi Suhara. 2025.
   *When2Call: When (not) to Call Tools.* In Proceedings of the 2025
   Conference of the Nations of the Americas Chapter of the Association for
   Computational Linguistics: Human Language Technologies (Volume 1: Long
   Papers), pages 3391–3409, Albuquerque, New Mexico. Association for
   Computational Linguistics. <https://aclanthology.org/2025.naacl-long.174/> (Call / refuse / clarify / answer decision.)
4. **In-Vehicle Task-Oriented Dialogue** — Huifang Du, Shuqin Li, Yi Dai, and
   Haofen Wang. 2025. *Effortless In-Vehicle Task-Oriented Dialogue: Enhancing
   Natural and Efficient Interactions.* In Extended Abstracts of the CHI
   Conference on Human Factors in Computing Systems (CHI EA '25), Article 213,
   1–10. ACM. <https://doi.org/10.1145/3706599.3719799> (Multi-turn in-vehicle
   dialogue structure.)
5. **CAR-bench** — Johannes Kirmayr, Lukas Stappen, and Elisabeth André. 2026.
   *CAR-bench: Evaluating the Consistency and Limit-Awareness of LLM Agents
   under Real-World Uncertainty.* arXiv:2601.22027.
   <https://arxiv.org/abs/2601.22027> (Hallucination / limit-awareness and
   disambiguation tasks — inspiration for the negative subsets.)
6. **CTFusion** — Daniel Rim, Minsoo Cho, Changwoo Chun, and Jaegul Choo. 2025.
   *To Chat or Task: a Multi-turn Dialogue Generation Framework for
   Task-Oriented Dialogue Systems.* In Proceedings of the 63rd Annual Meeting of
   the Association for Computational Linguistics (Volume 6: Industry Track),
   pages 576–592, Vienna, Austria. Association for Computational Linguistics.
   <https://aclanthology.org/2025.acl-industry.41/> (Multi-turn chat/task
   dialogue generation and persona/slot augmentation.)

## Citation

```bibtex
@misc{nova_iva_toolcalls_2026,
  title        = {Nova IVA Tool-Calls v0.2: A Synthetic Dataset for
                  In-Vehicle Assistant Tool Calling},
  author       = {Senthil Kumar N},
  year         = {2026},
  howpublished = {https://huggingface.co/datasets/Senthi1Kumar/nova-iva-toolcalls-v0.2},
  note         = {Synthetic English tool-calling dataset with schema-validated
                  function calls, when2call behaviors, and a held-out
                  novel-tool split for zero-shot generalization.}
}
```

## License

Released for research use. The dataset is fully synthetic (no scraped user
data). Generated with third-party LLMs via OpenRouter; downstream users are
responsible for compliance with those providers' terms. Not affiliated with,
or endorsed by, any vehicle manufacturer or model provider.