apigen-inferred

A verified, GPT-5.5-distilled subset of the argilla/apigen-function-calling dataset (109k rows in the upstream), with every golden tool-call argument labelled as literal or dependency-derived to enable a clean function-calling benchmark.

Pipeline

1. Filter the upstream to rows where every called API actually works (replay each tool call against the real implementation — distilabel Python functions or live RapidAPI / cached responses) → 45,984 rows.
2. Distill with GPT-5.5 (Responses API, reasoning_effort=medium): for every row we ran a multi-turn tool-using rollout that actually executes the tools, captured the final natural-language answer, and dropped any row where the model emitted <UNCALLABLE> (tool turned out broken at inference time) → 36,857 rows.
3. Classify golden args with GPT-5.5 (Batch API, reasoning_effort=low): for every argument in every golden tool call, decide whether the value is a literal (derivable from the user query alone) or a dependency (must come from a prior tool's output). Stored as golden_arg_kinds.

Columns

Column	Type	Source	Description
query	str	upstream	natural-language user request
tools	str (JSON)	upstream	list of tool specs available to the model
answers	str (JSON)	upstream	golden tool calls — list of {name, arguments}
id	float64	upstream	per-row id (NaN for distilabel rows)
hash_id	str	upstream	unique id (NaN for xLAM rows; use it for distilabel)
func_name	str	upstream	canonical function name (distilabel only)
func_desc	str	upstream	function description (distilabel only)
model_name	str	upstream	model that generated the original answers
origin	str	upstream	"distilabel" (Python fn) or "xLAM" (RapidAPI endpoint)
gpt55_answer	str	this repo	GPT-5.5's final natural-language answer after running the tools
gpt55_tool_calls	int64	this repo	number of tool calls GPT-5.5 made to produce the answer
golden_arg_kinds	str	this repo	per-call argument labels in the form fn1(arg:literal, arg:dependency),fn2(...) aligned with answers

Composition

origin	rows
distilabel (pure-Python tools)	33,888
xLAM (RapidAPI endpoints)	2,969
total	36,857

Mean tool calls per row: 1.67.

Benchmark protocol

This dataset is designed to be used as a function-calling benchmark with three orthogonal metrics:

• Function F1 — multiset comparison of called function names against the golden trajectory. Tests function selection independent of args.
• Param F1 — for each golden call, count only the literal args (per golden_arg_kinds); a literal arg is a TP if the model's matching call provided the same value. Excluding dependency args from the denominator keeps live-API non-determinism (different ids each run) from spuriously hurting correct trajectories.
• Answer accuracy (LLM-as-judge) — GPT-5.5 reads {query, tools, tool_results, model_answer} and votes yes/no on whether the answer satisfies the query, decoupled from any stale golden answer.

The evaluator implementation lives at gdgc-metacong/metacong-em under src/eval/.

Usage

from datasets import load_dataset
ds = load_dataset("gdgc-metacong/apigen-inferred", split="train")
print(ds[0])
# golden_arg_kinds example:
# "web_candles(time_bucket:literal, pair_id:dependency, start:literal, end:literal)"

import json
tools = json.loads(ds[0]["tools"])
answers = json.loads(ds[0]["answers"])

tools and answers are stored as JSON strings — call json.loads(...) to get native lists. golden_arg_kinds is a flat string of the form fn1(arg:label, arg:label),fn2(arg:label,...), with one entry per call in answers (same order). Each label is either literal or dependency.

Notes

• Both id and hash_id carry NaN for the origin they don't apply to. Use hash_id to dedupe / index distilabel rows and id for xLAM.
• The full per-row trace (every turn, every tool call, every tool result, reasoning summaries) is not in this dataset. It lives separately at ~80 MB JSONL in the source repo.
• Tools that GPT-5.5 found broken at inference time were dropped, so this set is stricter than the filter-stage parquet (45,984 rows).
• golden_arg_kinds was produced by GPT-5.5 (reasoning_effort=low) over the OpenAI Batch API; one classification call per row, with the model given the query and the full ordered list of golden tool calls. Output is rendered as fn1(arg:literal, arg:dependency),fn2(arg:literal,...), one parenthesised group per call in answers, in the same order.