open-athena/Structure-Closure-BFCL-v6

Structure Closure: BFCL-derived evaluation, native-format v6

This development benchmark tests whether a model can finish a supplied, unfinished assistant response. It separates closing a structure whose content is complete from continuing a structure whose content is incomplete.

The release contains 14,784 validation cases from 704 source tasks: 21 cases per task. It includes seven closure families plus repeated-tool-opener retention controls. Only the evaluation split is published here. The campaign's training split, private agent traces, and BFCL-Parity capability benchmark are not included.

What it tests

Family	Required behavior
JSON objects	Close an open object
JSON arrays	Close an open array
Nested JSON	Close nested arrays and objects in order
JSON strings	Finish quoted strings, including escape controls
Tool-call delimiters	Close a declared tool call in the pinned model's native serialization
Reasoning delimiters	Close a Snowball reasoning block
Code fences	Close the required backtick or tilde fence
Repeated-opener retention	Complete one tool call without opening another call inside it

Each family has 704 cases per applicable control. close_required supplies all content and asks for closing delimiters only. continue_required supplies an incomplete content prefix and a reference to reproduce. Additional value_continue_required and escape_continue_required cases test unfinished JSON values and escapes. opener_retention starts at an open tool-call boundary. Report these controls separately: syntax alone can reward closing too early.

Construction and provenance

The builder reads reference-answer arrays from the campaign's training-approved BFCL complement, then creates synthetic structures around those arrays and task identifiers. The validation partition contains 704 source tasks and is disjoint from the campaign's 2,814 training tasks and 123 BFCL-Parity tasks. This is a development validation set used during iteration, not an untouched final test set.

Source material comes from the Berkeley Function Calling Leaderboard, converted through Harbor's BFCL adapter. These are transformed reference answers, not captured Claude Code instructions, tool descriptions, or model rollouts. The synthetic write_result tool declaration is defined in the included builder.

Version v6 changes tool-family prompts to declare the tool and serialize it through the pinned tokenizer's chat template. Non-tool cases retain the v5 construction. Earlier compact, undeclared-tool prompts are a different experimental condition; their scores must not be combined with native-v6 scores.

provenance/token-manifest.json records the original construction hashes and counts, including the unpublished training split. provenance/case-manifest.json records the source partition and pre-tokenization construction. provenance/release.json identifies the exported split and bundled source files. Source code is copied without edits from Marin commit 01b9237f7169315ed2ddd84bd01171c93fd13897. The bundled scorer and parser files retain their Apache-2.0 notices. The data is a synthetic transformation of Apache-2.0 BFCL material; see the upstream license and this repository's LICENSE.

Load the evaluation

from datasets import load_dataset
from huggingface_hub import HfApi

REPO = "open-athena/Structure-Closure-BFCL-v6"
REVISION = HfApi().dataset_info(REPO).sha  # Save this SHA with your results.

cases = load_dataset(
    REPO,
    "native-v6",
    split="validation",
    revision=REVISION,
)
assert len(cases) == 14784

Pin the dataset commit returned by the Hub for a reproducible experiment. Each row contains case_id, task_id, family, control, format, instruction, prefix, expected, exact prompt_token_ids and target_token_ids, and a prompt hash.

For the campaign's exact evaluation, use tokenizer open-athena/Grug-67B-A2B-BFCL-Protocol-FTPO at revision d761ea0a94500c2aa24aa4cd71b5a149d962e5c8. Feed prompt_token_ids directly to a continuation-generation interface. Do not wrap them in another chat template. Decode generated tokens with special tokens retained; tool and reasoning closing markers are part of the answer. Do not send target_token_ids to the model: they are reference continuations.

For another tokenizer or model format, reconstruct and audit the prompts, including native tool declarations and delimiters. Treat that as a separately versioned benchmark condition. Tokenizing the concatenated prompt and reference can differ from concatenating their individual tokenizations; canonical_joint_encoding_matches records this distinction.

The campaign evaluation uses one continuation per case, a 1,024-new-token limit, temperature 0, top-p 1, top-k disabled, repetition penalty 1, and no custom stop strings. The context limit is 32,768 tokens and the run seed is 42. Normal model EOS termination remains enabled. Do not configure tool or reasoning closers as stop strings that remove those delimiters from the scored text. provenance/generation.json records these settings and the runtime revision.

Score a continuation

Download the included scorer and add its src directory to the Python import path:

import sys
from huggingface_hub import snapshot_download

root = snapshot_download(
    REPO,
    repo_type="dataset",
    revision=REVISION,
    allow_patterns=["src/**"],
)
sys.path.insert(0, root + "/src")
from rolloutengine.closure_scoring import (
    ClosureFormat, closure_response_content, score_closure_region,
)

case = cases[0]
continuation = "}"  # Replace with the model's generated continuation.
continuation = closure_response_content(continuation, stop_reason="stop")
score = score_closure_region(
    case["prefix"] + continuation,
    case["expected"],
    ClosureFormat(case["format"]),
)
print(score)

The bundled scorer requires Python 3.11+ and only the standard library. Map a normal EOS or configured-stop termination to stop_reason="stop"; use "length" for token-budget exhaustion. Other labels do not trigger cleanup. Normal-stop cleanup removes one terminal Snowball turn-end marker; it does not remove structural closers or excuse truncation.

For each (family, control) group, report 100 * sum(score.syntax_complete) / scored_count for structural closure. Report content_preserved (also returned as success), trailing_content, and whole_response_success separately. The first outer structure is scored; whole_response_success also requires no trailing content. Syntax completion is the campaign's closure-table metric. Content-preserving success and continuation controls are necessary additional checks. Preserve case IDs and report missing or infrastructure-failed cases separately instead of converting them to model failures. Every expected group has 704 cases; the complete family/control inventory is in provenance/token-manifest.json. source/eval_audit.py contains the campaign's full-coverage audit.

Current limitations

These are conditional synthetic probes. They do not measure free-generation tool use, useful task progress, or BFCL task success. Models can finish a supplied structure yet fail to choose or invoke a tool during an agent task.

In the current native-v6 audit, the base checkpoint and both tested repair checkpoints each close all 704 native-tool close_required cases, with content preserved and no trailing content. That subtest has a ceiling and demonstrates no learned improvement. Harder native-format cases are needed to measure a reduction in that failure mode. Other families and continuation controls remain separate measurements.

The seven families are not a universal parser for all paired tokens. Tool and reasoning formats are model-specific. The benchmark is public and has been used during model development; it should not be presented as a contamination-free capability test.