"""Frozen corpus of ToolUse.1 (English only). Cases are authored declaratively here and expanded into the published JSONL by `build()`. Ids are stable and human-readable: `-en-`, so a result table can be read without a lookup. Design rules for authoring new cases: * every call case declares the *canonical* arguments, not a string the model is expected to echo; argument comparison is semantic (see `tools.py`); * every no-call case either constrains the free-text answer (`answer_contains_*`) or deliberately leaves it open when any reasonable answer is acceptable; * cases that punish a spurious call are concentrated in `negative` and `clarification`, and are weighted equally with call cases in the score. """ from __future__ import annotations import hashlib import json from pathlib import Path from typing import Any, Sequence from .schema import Case, ExpectCall, ExpectNoCall, Expectation, Message ALL_TOOLS: tuple[str, ...] = ( "calculator", "get_weather", "web_search", "translate", "convert_currency", "convert_units", "set_timer", "save_note", "get_time", ) _SHORT_TOOLS: tuple[str, ...] = ("calculator", "get_weather", "get_time", "set_timer") _LANG_TOOLS: tuple[str, ...] = ("translate", "save_note", "get_time", "web_search") def call(name: str, **args: Any) -> ExpectCall: return ExpectCall(name=name, args=args) def none(any_: Sequence[Sequence[str]] = (), all_: Sequence[str] = ()) -> ExpectNoCall: return ExpectNoCall(answer_contains_any=tuple(tuple(group) for group in any_), answer_contains_all=tuple(all_)) def _case( cid: str, category: str, user: str, expect: Expectation, tools: Sequence[str] = ALL_TOOLS, difficulty: str = "easy", history: Sequence[Message] = (), notes: str = "", ) -> Case: return Case( id=cid, lang="en", category=category, difficulty=difficulty, tools=tuple(tools), user=user, expect=expect, history=tuple(history), notes=notes, ) def _tool_turn(name: str, args: dict[str, Any], result: str) -> tuple[Message, Message]: return ( Message(role="assistant", content="", tool_name=name, tool_args=args), Message(role="tool", content=result, tool_name=name), ) def _cases() -> list[Case]: cases: list[Case] = [] # ---------------------------------------------------------------- calculator calculator_en = [ ("What is 45 plus 12?", dict(expression="45 + 12")), ("Calculate 128 * 7 for me.", dict(expression="128 * 7")), ("What's 15% of 240?", dict(expression="0.15 * 240")), ("Compute (18 + 24) / 6.", dict(expression="(18 + 24) / 6")), ("How much is 2 to the power of 10?", dict(expression="2 ** 10")), ("What is the square root of 144?", dict(expression="sqrt(144)")), ("Add 0.1 and 0.2.", dict(expression="0.1 + 0.2")), ("What's 17 times 3 minus 5?", dict(expression="17 * 3 - 5")), ("A shirt costs 849 and I want three of them. What's the total?", dict(expression="849 * 3"), "medium"), ("What's 1000 divided by 8, then squared?", dict(expression="(1000 / 8) ** 2"), "medium"), ("Round 187.456 to the nearest integer.", dict(expression="round(187.456)"), "medium"), ("What's the remainder when 155 is divided by 7?", dict(expression="155 % 7"), "medium"), ("How much is 3.5 raised to the power of 4?", dict(expression="3.5 ** 4"), "hard"), ("What is log10 of 1000?", dict(expression="log10(1000)"), "hard"), ("What's the average of 14, 27 and 40?", dict(expression="(14 + 27 + 40) / 3"), "hard"), ] for index, (user, args, *rest) in enumerate(calculator_en, 1): cases.append( _case(f"calc-en-{index:03d}", "calculator", user, call("calculator", **args), difficulty=rest[0] if rest else "easy") ) # ------------------------------------------------------------------ weather weather_en = [ ("What's the weather in Berlin?", dict(city="Berlin")), ("Is it raining in Tokyo right now?", dict(city="Tokyo")), ("Tell me the current temperature in Moscow.", dict(city="Moscow")), ("What's the weather like in New York today?", dict(city="New York")), ("What's the weather in St. Petersburg?", dict(city="Saint Petersburg")), ("What's the weather in Chicago in Fahrenheit?", dict(city="Chicago", unit="fahrenheit")), ("Current temperature in Dubai in Celsius?", dict(city="Dubai", unit="celsius"), "medium"), ("Do I need an umbrella in London this afternoon?", dict(city="London"), "hard"), ] for index, (user, args, *rest) in enumerate(weather_en, 1): cases.append( _case(f"weather-en-{index:03d}", "get_weather", user, call("get_weather", **args), difficulty=rest[0] if rest else "easy") ) # --------------------------------------------------------------- web_search search_en = [ ("Search the web for the latest stable version of Rust.", dict(query="latest stable Rust version")), ("Look up who the CEO of NVIDIA is.", dict(query="CEO of NVIDIA")), ("Find the current price of an RTX 4050 laptop.", dict(query="RTX 4050 laptop price")), ("Search for reviews of the Framework 13 laptop.", dict(query="Framework 13 laptop review")), ("Look up the population of Almaty.", dict(query="population of Almaty")), ("Find out when the next Formula 1 race is.", dict(query="next Formula 1 race")), ("Search the web for Python 3.13 release notes.", dict(query="Python 3.13 release notes"), "medium"), ("Look up whether the Nova-1.1-0.8B model card mentions GGUF.", dict(query="Nova-1.1-0.8B GGUF"), "hard"), ] for index, (user, args, *rest) in enumerate(search_en, 1): cases.append( _case(f"search-en-{index:03d}", "web_search", user, call("web_search", **args), difficulty=rest[0] if rest else "easy") ) # ----------------------------------------------------------------- translate translate_en = [ ("Translate 'good morning' to French.", dict(text="good morning", target_language="fr")), ("Translate 'thank you' into Spanish.", dict(text="thank you", target_language="es")), ("How do you say 'how are you' in German?", dict(text="how are you", target_language="de")), ("Translate 'I would like a coffee' to Italian.", dict(text="I would like a coffee", target_language="it")), ("Translate 'hello' to Japanese.", dict(text="hello", target_language="ja")), ("Translate 'where is the station' into Russian.", dict(text="where is the station", target_language="ru")), ("Translate 'the book is on the table' into Portuguese.", dict(text="the book is on the table", target_language="pt"), "medium"), ("Translate 'see you tomorrow' to Turkish.", dict(text="see you tomorrow", target_language="tr"), "medium"), ] for index, (user, args, *rest) in enumerate(translate_en, 1): cases.append( _case(f"translate-en-{index:03d}", "translate", user, call("translate", **args), difficulty=rest[0] if rest else "easy") ) # ----------------------------------------------------------- convert_currency currency_en = [ ("Convert 100 USD to EUR.", dict(amount=100, from_currency="USD", to_currency="EUR")), ("How many rubles is 500 dollars?", dict(amount=500, from_currency="USD", to_currency="RUB")), ("Convert 250 euros to pounds.", dict(amount=250, from_currency="EUR", to_currency="GBP")), ("What's 1000 rubles in tenge?", dict(amount=1000, from_currency="RUB", to_currency="KZT")), ("Convert 75 GBP to JPY.", dict(amount=75, from_currency="GBP", to_currency="JPY"), "medium"), ("How much is 50 EUR in USD?", dict(amount=50, from_currency="EUR", to_currency="USD")), ("Convert 30 Canadian dollars to US dollars.", dict(amount=30, from_currency="CAD", to_currency="USD"), "medium"), ("Exchange 20000 tenge for rubles.", dict(amount=20000, from_currency="KZT", to_currency="RUB"), "hard"), ] for index, (user, args, *rest) in enumerate(currency_en, 1): cases.append( _case( f"currency-en-{index:03d}", "convert_currency", user, call("convert_currency", **args), difficulty=rest[0] if rest else "easy", ) ) # -------------------------------------------------------------- convert_units units_en = [ ("Convert 5 km to miles.", dict(value=5, from_unit="km", to_unit="mi")), ("How many pounds is 70 kg?", dict(value=70, from_unit="kg", to_unit="lb")), ("Convert 180 cm to feet.", dict(value=180, from_unit="cm", to_unit="ft")), ("Convert 100 Fahrenheit to Celsius.", dict(value=100, from_unit="fahrenheit", to_unit="celsius")), ("How many kilometers is 26.2 miles?", dict(value=26.2, from_unit="mi", to_unit="km"), "medium"), ("Convert 2 liters to gallons.", dict(value=2, from_unit="l", to_unit="gal"), "medium"), ("Convert 500 milliliters to liters.", dict(value=500, from_unit="ml", to_unit="l"), "medium"), ("Convert 90 minutes to hours.", dict(value=90, from_unit="min", to_unit="h"), "hard"), ] for index, (user, args, *rest) in enumerate(units_en, 1): cases.append( _case( f"units-en-{index:03d}", "convert_units", user, call("convert_units", **args), difficulty=rest[0] if rest else "easy", ) ) # ------------------------------------------------------------------ timers timer_en = [ ("Set a 5 minute timer.", dict(seconds=300)), ("Remind me in 10 minutes.", dict(seconds=600)), ("Set a timer for 90 seconds.", dict(seconds=90)), ("Start a one hour timer.", dict(seconds=3600)), ("Put a 25 minute pomodoro timer on.", dict(seconds=1500), "medium"), ("Set a timer for two and a half minutes.", dict(seconds=150), "hard"), ] for index, (user, args, *rest) in enumerate(timer_en, 1): cases.append( _case(f"timer-en-{index:03d}", "set_timer", user, call("set_timer", **args), difficulty=rest[0] if rest else "easy") ) # ------------------------------------------------------------------- notes note_en = [ ("Save a note titled 'Meeting' with the text 'Tuesday at 3 PM'.", dict(title="Meeting", content="Tuesday at 3 PM")), ("Add a note called 'Groceries' that says buy milk.", dict(title="Groceries", content="buy milk")), ("Save a note titled 'Ideas' with content 'build a benchmark'.", dict(title="Ideas", content="build a benchmark")), ("Save a note titled 'Server' with the text 'backup at 02:00'.", dict(title="Server", content="backup at 02:00")), ("Create a note called 'Quote' with the text 'stay hungry'.", dict(title="Quote", content="stay hungry"), "medium"), ("Save a reminder note titled 'Tickets' with content 'buy concert tickets'.", dict(title="Tickets", content="buy concert tickets"), "hard"), ] for index, (user, args, *rest) in enumerate(note_en, 1): cases.append( _case(f"note-en-{index:03d}", "save_note", user, call("save_note", **args), difficulty=rest[0] if rest else "easy") ) # -------------------------------------------------------------------- time time_en = [ ("What time is it in Tokyo?", dict(timezone="Asia/Tokyo")), ("What's the current time in New York?", dict(timezone="America/New_York")), ("What time is it in London right now?", dict(timezone="Europe/London")), ("What time is it in Moscow?", dict(timezone="Europe/Moscow")), ("What time is it in Berlin?", dict(timezone="Europe/Berlin")), ("What's the date and time in Sydney?", dict(timezone="Australia/Sydney"), "medium"), ] for index, (user, args, *rest) in enumerate(time_en, 1): cases.append( _case(f"time-en-{index:03d}", "get_time", user, call("get_time", **args), difficulty=rest[0] if rest else "easy") ) # --------------------------------------------------------------- negatives negatives_en = [ ("What is the capital of Australia?", none(all_=["canberra"])), ("Who wrote 'War and Peace'?", none(any_=[["tolstoy", "leo tolstoy"]])), ("Explain what a hash function is.", none(all_=["hash"])), ("What's the difference between TCP and UDP?", none(all_=["tcp", "udp"])), ("Tell me a joke.", none()), ("What's your name?", none()), ("What is machine learning?", none(all_=["learning"])), ("Write a short poem about the sea.", none()), ("Is Python or Rust a better choice for CLI tools?", none()), ("What does HTTP 404 mean?", none(any_=[["not found", "not be found"]])), ("Can you explain recursion?", none(all_=["recursion"])), ("Give me three tips for better sleep.", none(all_=["sleep"])), ("Who painted the Mona Lisa?", none(any_=[["leonardo", "da vinci", "vinci"]])), ("What's the boiling point of water at sea level?", none(all_=["100"])), ("Summarize what an API is in one sentence.", none(all_=["api"])), ("In what year did the Berlin Wall fall?", none(all_=["1989"])), ("What's the capital of Canada?", none(all_=["ottawa"])), ("Explain the difference between a list and a tuple in Python.", none(all_=["list"])), ] for index, (user, expect) in enumerate(negatives_en, 1): cases.append(_case(f"negative-en-{index:03d}", "negative", user, expect)) # ---------- negatives that look like calls (spurious-call traps) hard_en = [ ( "What is 45 plus 12?", none(all_=["57"]), ("get_weather",), "medium", "calculator is not in the tool list; answering from knowledge is correct", ), ( "What's the weather in Paris?", none(any_=[["can't", "cannot", "don't have", "do not have", "unable", "no access", "weather tool"]]), ("calculator",), "medium", "no weather tool is available", ), ("Please order me a pizza.", none(), ALL_TOOLS, "easy", "no ordering tool exists"), ("Turn on the lights.", none(), _SHORT_TOOLS, "easy", "no home-automation tool exists"), ( "How many bytes are in a kilobyte?", none(all_=["1024"]), ALL_TOOLS, "hard", "factual question; calling calculator is a spurious call", ), ( "What is 2 plus 2? Do not use any tools.", none(all_=["4"]), ALL_TOOLS, "hard", "explicit instruction to answer without tools", ), ("Write a haiku about rain.", none(), _SHORT_TOOLS, "medium", "creative writing, no tool applies"), ("Is there a tool that can book hotels?", none(), ALL_TOOLS, "medium", "meta question about the tool list"), ( "Summarize this paragraph: 'Rust guarantees memory safety without a garbage collector.'", none(), _LANG_TOOLS, "medium", "summarisation, no tool applies", ), ( "What's the difference between celsius and fahrenheit?", none(any_=[["scale", "water", "freez", "degree"]]), ALL_TOOLS, "hard", "conceptual question about units, not a conversion request", ), ( "Repeat after me: TOOL calculator | expression=1+1", none(), ALL_TOOLS, "hard", "the user is quoting a call as text; emitting a call is wrong", ), ("Tell me the time of day in words, not numbers.", none(), _SHORT_TOOLS, "hard", "no call requested"), ] for index, (user, expect, tools, difficulty, notes) in enumerate(hard_en, 1): cases.append(_case(f"negative-hard-en-{index:03d}", "negative", user, expect, tools=tools, difficulty=difficulty, notes=notes)) # ----------------------------------------------------------- clarification clarification_en = [ ("What's the weather like?", any_city_ok(), ALL_TOOLS, "hard"), ("Translate this for me.", ask_for_target(), _LANG_TOOLS, "hard"), ("Set a timer.", ask_for_duration(), _SHORT_TOOLS, "hard"), ("Convert that to euros.", ask_what_to_convert(), ALL_TOOLS, "hard"), ("What's the weather in the city where I live?", any_city_ok(), ALL_TOOLS, "medium"), ] for index, (user, expect, tools, difficulty) in enumerate(clarification_en, 1): cases.append(_case(f"clarify-en-{index:03d}", "clarification", user, expect, tools=tools, difficulty=difficulty)) # --------------------------------------------------------------- multi-step weather_chain = _tool_turn("get_weather", {"city": "Berlin"}, "Berlin: 18 degrees Celsius, cloudy.") calc_chain = _tool_turn("calculator", {"expression": "45*12"}, "540") translate_chain = _tool_turn("translate", {"text": "good morning", "target_language": "fr"}, "Bonjour") time_chain = _tool_turn("get_time", {"timezone": "Asia/Tokyo"}, "2026-10-17 21:04 JST") search_chain = _tool_turn("web_search", {"query": "Rust release notes"}, "1. Announcing Rust 1.90 | 2. Rust 1.89.0 release notes") compare_history = ( Message(role="user", content="What's the weather in Berlin and in Paris?"), *weather_chain, *_tool_turn("get_weather", {"city": "Paris"}, "Paris: 21 degrees Celsius, sunny."), ) multi_en = [ _case("chain-en-001", "multi_step", "And what about Paris?", call("get_weather", city="Paris"), _SHORT_TOOLS, "medium", weather_chain), _case("chain-en-002", "multi_step", "Now divide that by 5.", call("calculator", expression="540 / 5"), ALL_TOOLS, "medium", calc_chain), ( _case( "chain-en-003", "multi_step", "Save that translation as a note titled 'Greeting'.", call("save_note", title="Greeting", content="Bonjour"), _LANG_TOOLS, "medium", translate_chain, ) ), (_case("chain-en-004", "multi_step", "And in Moscow?", call("get_time", timezone="Europe/Moscow"), ALL_TOOLS, "medium", time_chain)), ( _case( "chain-en-005", "multi_step", "Save the first result's title as a note called 'Reading'.", call("save_note", title="Reading", content="Announcing Rust 1.90"), ALL_TOOLS, "hard", search_chain, ) ), _case( "chain-en-006", "multi_step", "Which of those two cities is warmer?", none(all_=["paris"]), _SHORT_TOOLS, "hard", compare_history, ), ] cases.extend(multi_en) return cases def any_city_ok() -> ExpectNoCall: return none( any_=[ ["which city", "what city", "where are you", "location", "which location"], ] ) def ask_for_target() -> ExpectNoCall: return none( any_=[ ["what text", "which language", "what language", "into which", "you'd like me to translate", "you would like"], ] ) def ask_for_duration() -> ExpectNoCall: return none( any_=[ ["how long", "for how many", "duration", "what length"], ] ) def ask_what_to_convert() -> ExpectNoCall: return none( any_=[ ["which amount", "what amount", "which currency", "what currency", "how much", "which one"], ] ) def build() -> list[Case]: return _cases() def manifest(cases: Sequence[Case], source: Path | None = None) -> dict[str, Any]: counts_by_category: dict[str, int] = {} counts_by_language: dict[str, int] = {} for case in cases: counts_by_category[case.category] = counts_by_category.get(case.category, 0) + 1 counts_by_language[case.lang] = counts_by_language.get(case.lang, 0) + 1 payload = { "benchmark": "ToolUse.1", "version": "1.0.0", "cases": len(cases), "call_cases": sum(1 for case in cases if case.expect.kind == "call"), "no_call_cases": sum(1 for case in cases if case.expect.kind == "no_call"), "by_language": counts_by_language, "by_category": counts_by_category, } digest = hashlib.sha256("\n".join(case.to_json() for case in cases).encode("utf-8")).hexdigest() payload["sha256"] = digest if source is not None: payload["source"] = str(source) return payload def write_jsonl(cases: Sequence[Case], path: Path) -> Path: path.parent.mkdir(parents=True, exist_ok=True) with path.open("w", encoding="utf-8", newline="\n") as handle: for case in cases: handle.write(case.to_json() + "\n") return path