harn-vm 0.10.63

Async bytecode virtual machine for the Harn programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use super::*;

use crate::llm_config::ModelEligibilityMeasurementKind;

#[test]
fn downstream_bindings_include_automatic_eligibility_shape() {
    let typescript = typescript_declarations();
    assert!(typescript.contains("automatic_eligibility?: HarnAutomaticModelEligibility"));
    assert!(typescript
        .contains("kind: \"meter_holdout\" | \"tool_call_fidelity\" | \"provider_health\""));

    let swift = swift_binding().expect("swift binding renders");
    assert!(swift.contains("public let automaticEligibility: HarnAutomaticModelEligibility?"));
    assert!(swift.contains("public struct HarnModelEligibilityMeasurement"));
}

#[test]
fn generated_catalog_exports_one_measured_fireworks_automatic_default() {
    let catalog = artifact();
    let automatic = catalog
        .variants
        .iter()
        .filter(|variant| variant.automatic_eligibility.is_some())
        .collect::<Vec<_>>();
    assert_eq!(automatic.len(), 1, "catalog must own one automatic default");
    assert_eq!(automatic[0].id, "balanced");
    assert_eq!(automatic[0].provider, "fireworks");
    assert_eq!(
        automatic[0].model_id,
        "accounts/fireworks/models/gpt-oss-120b"
    );
    let receipts = &automatic[0]
        .automatic_eligibility
        .as_ref()
        .expect("automatic eligibility")
        .receipts;
    assert_eq!(receipts.len(), 3);
    assert_eq!(
        receipts
            .iter()
            .map(|receipt| (receipt.kind, receipt.passed, receipt.trials))
            .collect::<Vec<_>>(),
        vec![
            (ModelEligibilityMeasurementKind::MeterHoldout, 80, 100),
            (ModelEligibilityMeasurementKind::ToolCallFidelity, 97, 100),
            (ModelEligibilityMeasurementKind::ProviderHealth, 99, 100),
        ]
    );
}

#[test]
fn validation_rejects_unmeasured_or_ambiguous_automatic_variants() {
    let mut catalog = artifact();
    let eligibility = catalog
        .variants
        .iter()
        .find_map(|variant| variant.automatic_eligibility.clone())
        .expect("shipped automatic eligibility");
    catalog.variants[0].automatic_eligibility = Some(eligibility);
    let report = validate_artifact(&catalog);
    assert!(report
        .errors
        .iter()
        .any(|error| error.contains("automatic model variants; exactly zero or one is allowed")));

    let automatic = catalog
        .variants
        .iter_mut()
        .find(|variant| variant.id == "balanced")
        .expect("balanced variant");
    automatic
        .automatic_eligibility
        .as_mut()
        .expect("automatic eligibility")
        .receipts[0]
        .trials = 0;
    let report = validate_artifact(&catalog);
    assert!(report
        .errors
        .iter()
        .any(|error| error.contains("zero-trial measurement receipt")));

    let mut missing_health = artifact();
    missing_health
        .variants
        .iter_mut()
        .find(|variant| variant.id == "balanced")
        .expect("balanced variant")
        .automatic_eligibility
        .as_mut()
        .expect("automatic eligibility")
        .receipts
        .retain(|receipt| receipt.kind != ModelEligibilityMeasurementKind::ProviderHealth);
    let report = validate_artifact(&missing_health);
    assert!(report
        .errors
        .iter()
        .any(|error| error.contains("must carry a provider_health receipt")));
}