Skip to main content

inferlab_protocol/
measurement_data_asset.rs

1//! Wire declarations owned by measurement data-asset preparation.
2
3use crate::wire::{BenchAgenticSourceInput, ClientStatus, EvalDefinitionInput, ProtocolVersion};
4use schemars::JsonSchema;
5use serde::{Deserialize, Serialize};
6use std::collections::BTreeMap;
7use std::path::PathBuf;
8
9/// One narrowly scoped source-preparation request issued before measurement
10/// materialization. The selected measurement definition remains authoritative
11/// for dataset semantics.
12#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
13#[serde(deny_unknown_fields)]
14pub struct MeasurementDataAssetPreparationRequest {
15    pub protocol_version: ProtocolVersion,
16    pub phase: MeasurementDataAssetPreparationPhase,
17    pub source: MeasurementDataAssetSourceInput,
18    pub artifact_dir: PathBuf,
19}
20
21/// One externally observable source-preparation phase. Separating resolution
22/// from acquisition lets the control plane durably commit each result.
23#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
24#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
25pub enum MeasurementDataAssetPreparationPhase {
26    Resolve,
27    SnapshotLocal,
28    Acquire {
29        resolved_revision: String,
30        cache_state_before: MeasurementDataAssetCacheOutcome,
31    },
32    /// Materialize a release-pinned AIPerf public dataset into rows the
33    /// control plane verifies against the catalog digest.
34    Materialize,
35}
36
37/// The next separately durable preparation phase selected by the owning
38/// runtime after source resolution.
39#[derive(Clone, Copy, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
40#[serde(rename_all = "snake_case")]
41pub enum MeasurementDataAssetPreparationNextPhase {
42    SnapshotLocal,
43}
44
45/// The measurement-owned source whose bytes or task selection are prepared.
46#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
47#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
48pub enum MeasurementDataAssetSourceInput {
49    Eval {
50        workspace_root: PathBuf,
51        #[serde(default)]
52        workspace_source_exclusions: Vec<PathBuf>,
53        definition: Box<EvalDefinitionInput>,
54    },
55    Agentic {
56        source: Box<BenchAgenticSourceInput>,
57    },
58    /// A release-catalog source whose rows only the release-pinned AIPerf's
59    /// public-dataset materialization can produce
60    /// ([[RFC-0004:C-BENCH-REQUEST-SOURCES]]).
61    AiperfPublicDataset {
62        dataset: String,
63        output_path: PathBuf,
64        /// Machine-local directory AIPerf's working-directory-relative
65        /// dataset cache resolves under.
66        cache_root: PathBuf,
67    },
68}
69
70/// A normalized mapping from dataset split names to selected file patterns.
71#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
72#[serde(transparent)]
73pub struct MeasurementDataFiles(pub BTreeMap<String, Vec<String>>);
74
75/// The effective selection reported by the owning measurement runtime.
76#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
77#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
78pub enum MeasurementDataAssetEffectiveSelection {
79    Eval {
80        task_identity: String,
81        #[serde(default)]
82        dataset_path: Option<String>,
83        #[serde(default)]
84        dataset_name: Option<String>,
85        #[serde(default)]
86        evaluation_split: Option<String>,
87        #[serde(default)]
88        fewshot_split: Option<String>,
89        #[serde(default)]
90        data_files: Option<MeasurementDataFiles>,
91    },
92    Agentic {
93        repository: String,
94        requested_revision: String,
95        #[serde(default)]
96        observed_revision: Option<String>,
97        filename: String,
98    },
99}
100
101/// One member of a complete, ordered content closure.
102#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
103#[serde(deny_unknown_fields)]
104pub struct MeasurementDataAssetContentEntry {
105    pub relative_path: String,
106    pub sha256: String,
107}
108
109/// Expected-versus-observed integrity evidence for qualified source content.
110#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
111#[serde(deny_unknown_fields)]
112pub struct MeasurementDataAssetVerification {
113    pub subject: String,
114    pub expected: String,
115    #[serde(default)]
116    pub observed: Option<String>,
117    pub matched: bool,
118}
119
120/// The complete immutable source identity established by preparation.
121#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
122#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
123pub enum MeasurementDataAssetAcquiredSource {
124    ReleaseQualified {
125        identity: String,
126        closure: Vec<MeasurementDataAssetContentEntry>,
127    },
128    LocalFileClosure {
129        source_root: PathBuf,
130        files: Vec<MeasurementDataAssetContentEntry>,
131    },
132}
133
134/// The immutable workspace-task snapshot consumed by one Eval client.
135#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
136#[serde(deny_unknown_fields)]
137pub struct EvalPreparedSourceBinding {
138    pub workspace_root: PathBuf,
139    pub task_path: PathBuf,
140}
141
142/// Whether preparation established a closed source or an explicitly opaque
143/// non-reproducible source.
144#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
145#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
146pub enum MeasurementDataAssetReadiness {
147    Closed {
148        acquired_source: Box<MeasurementDataAssetAcquiredSource>,
149        #[serde(default)]
150        verification: Vec<MeasurementDataAssetVerification>,
151        #[serde(default, skip_serializing_if = "Option::is_none")]
152        eval_binding: Option<Box<EvalPreparedSourceBinding>>,
153    },
154    Opaque {
155        reason: String,
156        #[serde(default)]
157        unresolved_path: Option<PathBuf>,
158        deferred_source_access: bool,
159    },
160}
161
162/// Read-only or preparation-time outcome for one independently owned cache.
163#[derive(Clone, Copy, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
164#[serde(rename_all = "snake_case")]
165pub enum MeasurementDataAssetCacheOutcome {
166    FullHit,
167    Miss,
168    PartialReuse,
169    Unavailable,
170}
171
172/// One effective physical cache store as reported by its owning runtime.
173#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
174#[serde(deny_unknown_fields)]
175pub struct MeasurementDataAssetCacheStore {
176    pub authority: String,
177    pub purpose: String,
178    #[serde(default)]
179    pub path: Option<PathBuf>,
180    pub outcome: MeasurementDataAssetCacheOutcome,
181}
182
183/// Whether preparation contacted a remote metadata authority.
184#[derive(Clone, Copy, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
185#[serde(rename_all = "snake_case")]
186pub enum MeasurementDataAssetRemoteMetadataOutcome {
187    NotAccessed,
188    Accessed,
189    Unavailable,
190}
191
192/// Whether immutable source bytes were reused, downloaded, or materialized by
193/// a release-pinned AIPerf public dataset.
194#[derive(Clone, Copy, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
195#[serde(rename_all = "snake_case")]
196pub enum MeasurementDataAssetSourceBytesOutcome {
197    NotAccessed,
198    Reused,
199    Downloaded,
200    Materialized,
201    Unavailable,
202}
203
204/// Terminal result returned by the owning measurement runtime.
205#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
206#[serde(deny_unknown_fields)]
207pub struct MeasurementDataAssetPreparationResult {
208    pub schema_version: u32,
209    pub status: ClientStatus,
210    #[serde(default)]
211    pub effective_selection: Option<MeasurementDataAssetEffectiveSelection>,
212    #[serde(default)]
213    pub readiness: Option<MeasurementDataAssetReadiness>,
214    #[serde(default)]
215    pub next_phase: Option<MeasurementDataAssetPreparationNextPhase>,
216    #[serde(default)]
217    pub cache_stores: Vec<MeasurementDataAssetCacheStore>,
218    pub remote_metadata: MeasurementDataAssetRemoteMetadataOutcome,
219    pub source_bytes: MeasurementDataAssetSourceBytesOutcome,
220    #[serde(default)]
221    pub error: Option<String>,
222}