docs/dataset_adapter.md

Consumer-facing dataset adapter

agent_trajectories has two intentionally separate adapter layers:

1. Source adapters acquire a pinned external release and normalize its benchmark-specific rows into the canonical Trajectory schema. They run during ingestion or an explicit refresh.
2. The consumer adapter reads only the persisted canonical library and its read-only metadata index. Training and evaluation jobs never import benchmark parsers, contact upstream hosts, or rewrite dataset files.

The stable entry point is CanonicalDatasetAdapter. Its API version is 1.3; the package version is 0.5.0. Existing source, sampling and view interfaces remain supported.

from agent_trajectories import CanonicalDatasetAdapter

dataset = CanonicalDatasetAdapter("data/library")
print(dataset.available_benchmarks())
print(dataset.available_sources())

The adapter validates manifest.json, requires the persisted index.sqlite and available canonical shards, and opens SQLite in read-only mode. A federated release can contain full-inventory metadata while marking some payloads as metadata-only. It keeps only lightweight selected index rows in memory. Unsampled event payloads are parsed one trajectory at a time.

Query contract

DatasetQuery fields use OR semantics within a field and AND semantics across fields:

• benchmarks: stable families such as swe-bench, swe-gym, swe-smith, terminal-bench, tau2-bench, tau3-bench, browsecomp, mind2web, and toolbench;
• source_ids: exact canonical sources such as swegym_sampled or agentsuite_tau2;
• source_versions: exact immutable source revisions;
• agent_models and agent_scaffolds;
• trajectory_ids, task_keys, and compatible environment_keys;
• task-level library splits: train, validation, test, or protected_evaluation;
• quality_tiers and persisted task/environment quality_ranks;
• demonstration_provenance: expert_or_reference_demonstration or recorded_agent_completion;
• curated_selections: pinned original author training selections, enumerated by available_curated_selections();
• supported_views: records must support every requested view (full_trajectory or assistant_turn), checked before sampling;
• dynamic content_availability: hosted, overlay, or metadata_only;
• audited research_permissions, training_permissions, training_verifications, commercial_training_permissions, and transformed redistribution_permissions;
• structurally_eligible and training_eligible gates;
• selection: all_attempts, all_successful, or best_verified.

The concise string aliases all, successful, and best are also accepted, as are full/full-trajectory and turn/assistant-turn view names. Enum members are preferred when static typing is available.

DatasetQuery.for_training(...) enables both structural and training-source gates. This quality gate is not a legal-permission decision; combine it with the permission fields for the downstream project's policy. best_verified returns at most one successful source-evaluator or independently reproduced trajectory per selected task. Apply an environment_keys filter when alternatives from different environment versions must not compete. Quality rank itself is always calculated within a compatible task/environment group over the full canonical population; source filtering never silently rewrites the stored rank.

for_training always excludes protected_evaluation task assignments, even when a training source also contains that task. AReaL's unreconstructed contexts are explicitly turn-only records: only their source answer is supervised, earlier assistant messages are context, and full view raises an error. Exact contiguous AReaL dialogs support both views. See v0.5.0 SFT examples and author selections.

Expert demonstrations and successful agent completions are deliberately separate filters:

experts = DatasetQuery(
    demonstration_provenance=("expert_or_reference_demonstration",),
)
successful_agents = DatasetQuery(
    demonstration_provenance=("recorded_agent_completion",),
    selection=TrajectorySelection.ALL_SUCCESSFUL,
)

Full-trajectory SFT

from agent_trajectories import (
    CanonicalDatasetAdapter,
    DatasetQuery,
    TrainingView,
    TrajectorySelection,
)

dataset = CanonicalDatasetAdapter("data/library")
query = DatasetQuery.for_training(
    benchmarks=("swe-gym", "swe-smith"),
    splits=("train",),
    selection=TrajectorySelection.ALL_SUCCESSFUL,
)

for example in dataset.iter_examples(query, view=TrainingView.FULL_TRAJECTORY):
    row = example.to_dict()
    model_input = row["model_input"]
    loss_mask = row["loss_mask"]
    lineage = row["metadata"]["lineage"]
    # Apply a model-specific chat template/tokenizer downstream.

Each full example has the complete event sequence, assistant-only target_event_ids, and an aligned loss_mask. Outcomes, verification evidence and ranks are in metadata, never in model_input.

Assistant-turn SFT

query = DatasetQuery.for_training(
    source_ids=("agentsuite_tau2",),
    splits=("train",),
)

for turn in dataset.iter_examples(query, view=TrainingView.ASSISTANT_TURN):
    row = turn.to_dict()
    assert len(row["context"]) == row["target_index"]
    assert row["target_event_id"] == row["metadata"]["lineage"]["turn_id"]
    model_input = row["model_input"]       # causal prefix only
    supervised_target = row["supervised_target"]

Full and turn views derive from the same canonical record, retain the same task split and source lineage, and have equivalent assistant targets. Turn context contains no target event, future observation, later action, outcome, or answer.

Best trajectory and multiple completions

Select the best verified trajectory for every selected task:

best = DatasetQuery(
    benchmarks=("swe-bench",),
    splits=("protected_evaluation",),
    selection=TrajectorySelection.BEST_VERIFIED,
)
for record in dataset.iter_records(best):
    print(record.metadata.task_key, record.metadata.quality_rank)

Request one exact canonical trajectory:

record = dataset.get_trajectory("trajectory:...")
print(record.trajectory.events)
print(record.lineage())

Collapsed duplicate IDs are resolved to their retained canonical trajectory; contributing_trajectory_ids preserves every original ID.

Enumerate all completions for a task, in quality order:

first = next(dataset.metadata(DatasetQuery(source_ids=("agentsuite_tau2",))))
attempts = dataset.alternatives(first.task_key)
for attempt in attempts:
    print(
        attempt.metadata.trajectory_id,
        attempt.metadata.quality_rank,
        attempt.metadata.outcome_category,
        attempt.metadata.agent_model,
    )

environment_key= can restrict alternatives to one compatible environment.

Deterministic sampling

from agent_trajectories import SamplingConfig, SamplingStrategy

population = DatasetQuery.for_training(splits=("train",))

# Uniform trajectory sampling.
random_sample = SamplingConfig(count=1_000, seed=42)

# Uniform task sampling; the best matching attempt represents each drawn task.
task_sample = SamplingConfig(
    count=1_000, seed=42, strategy=SamplingStrategy.TASK
)

# Round-robin sources, then sample within each source.
balanced_sample = SamplingConfig(
    count=1_000, seed=42, strategy=SamplingStrategy.SOURCE_BALANCED
)

for record in dataset.iter_records(population, sampling=balanced_sample):
    print(record.metadata.trajectory_id, record.metadata.source_id)

Set with_replacement=True for repeated draws. The same persisted library, query, seed and sampling configuration produce the same ordered IDs. Task-level sampling prevents tasks with many recorded attempts from dominating. Source-balanced sampling distributes draws round-robin across non-empty sources and deterministically redistributes unused capacity when a source is exhausted.

Streaming and batching

for batch in dataset.iter_batches(
    8,
    DatasetQuery.for_training(splits=("train",)),
    view=TrainingView.ASSISTANT_TURN,
):
    rows = [example.to_dict() for example in batch]
    print(len(rows), rows[0]["sample_id"])

These are bounded Python batches, not tensors. Canonical storage stays framework-independent and downstream code retains control of templates, tokenization, truncation, packing and collation.

PyTorch is optional and imported lazily:

torch_dataset = dataset.as_torch_iterable(
    DatasetQuery.for_training(splits=("train",)),
    view=TrainingView.ASSISTANT_TURN,
)

# Standard torch DataLoader worker processes are sharded by item index.
from torch.utils.data import DataLoader
loader = DataLoader(torch_dataset, batch_size=None, num_workers=2)

The core package has no ML-framework dependency. Install the optional extra only when needed: pip install 'agent-trajectory-datasets[torch]'.

Evaluation over all trajectories

Task splits are assigned once by canonical task_key, then joined into every source and both derived views. A task cannot appear in more than one of train, validation, test, and protected_evaluation.

evaluation = DatasetQuery(
    benchmarks=("tau2-bench",),
    splits=("validation", "test", "protected_evaluation"),
    selection=TrajectorySelection.ALL_ATTEMPTS,
)

for record in dataset.iter_records(evaluation):
    print(record.metadata.task_key, record.trajectory.outcome.success)

For all references, source verdicts and verification evidence associated with one task:

task = next(dataset.metadata(evaluation)).task_key
bundle = dataset.evaluation_bundle(task, query=evaluation)
for reference in bundle.references:
    print(
        reference.trajectory_id,
        reference.outcome.success,
        reference.verification.method,
        reference.verification.evidence,
        reference.supervised_targets,
    )

Historical source outcomes are evaluation references, not scores for a new model. Native environment success still requires running the corresponding benchmark evaluator. Unknown outcomes remain unknown rather than being counted as failures.

Metadata and lineage

Every DatasetRecord carries TrajectoryMetadata, including:

• canonical task, trajectory and environment IDs;
• benchmark family, source ID, immutable revision, upstream record locator and canonical/source split;
• agent model and scaffold;
• quality tier, numeric score and within-task quality rank;
• structural/training eligibility;
• current payload availability and the complete source permission audit, including verification state, commercial-training status and conditions;
• outcome category, reward, verification method/strength and independent-replay status;
• every duplicate source trajectory ID collapsed into the canonical record.

record.lineage() adds the complete SourceRef, producer provenance, source outcome and full verification evidence. Derived examples store that object at example.metadata["lineage"]; assistant-turn examples also store turn_id and full examples store all supervised turn_ids.

Federated payloads and authorized overlays

available_sources() enumerates the complete indexed inventory; content_sources() lists sources whose event payload is currently readable. Inspect one permission record without loading trajectories:

rights = dataset.permissions("agentsuite_tau2")
print(rights.dimensions["model_training"])
print(dataset.content_availability("agentsuite_tau2"))

When a project is separately authorized to retrieve a metadata-only source, run its explicit pinned source adapter and provide the resulting canonical file or directory as an overlay:

dataset = CanonicalDatasetAdapter(
    "./sft-benchmark-trajectories",
    content_overlays={
        "agentsuite_tau2": "./authorized/canonical/agentsuite_tau2",
    },
)

query = DatasetQuery(
    source_ids=("agentsuite_tau2",),
    content_availability=("overlay",),
)
for record in dataset.iter_records(query):
    ...

The overlay is read-only and is not copied or uploaded. Canonical IDs join it to the hosted full-inventory index. Selecting records whose payload is still absent raises MissingTrajectoryContentError with the missing source IDs; metadata queries never silently discard them.

Initial ingestion and explicit refresh

Normal consumption performs no downloads. Initial ingestion is a separate, explicit operation. For a hosted release:

.venv/bin/python scripts/import_hf_release.py SOURCE_ID DATASET_ID \
  --revision IMMUTABLE_SHA \
  --output data/full/canonical/OUTPUT \
  --cache data/cache/full/OUTPUT \
  --config CONFIG --split SPLIT

.venv/bin/python scripts/build_complete_library.py \
  --input-dir data/full/canonical/OUTPUT \
  --output data/library

The complete multi-source build command and source-specific revisions are in the root README and docs/trajectory_sources.md.

A refresh is never implicit. Choose and audit a new upstream immutable SHA and write it to a new canonical output directory. For an existing published library, use the append workflow; it copies the old SQLite index, reads only the new canonical shards, preserves all old score rows and shard bytes, and updates only affected task assignments:

.venv/bin/python scripts/import_hf_release.py SOURCE_ID DATASET_ID \
  --revision NEW_IMMUTABLE_SHA \
  --output data/full/canonical/OUTPUT_NEW_SHA \
  --cache data/cache/full/OUTPUT_NEW_SHA \
  --config CONFIG --split SPLIT

# Review release-manifest.json and rejects before appending.
.venv/bin/python scripts/append_library.py \
  --base data/library \
  --input-dir data/increment-v0.4.0/canonical \
  --output data/library-v0.4.0 \
  --release v0.4.0

append_report.json explicitly records the base manifest hash, accepted and duplicate counts, affected tasks, and that base scores and shards were not reprocessed. This separation makes changes reviewable and keeps training runs pinned to the manifest and shard hashes they actually consumed.