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

use crate::value::{VmError, VmValue};

fn field(dict: &VmValue, key: &str) -> Option<String> {
    dict.as_dict()
        .and_then(|map| map.get(key))
        .map(VmValue::display)
}

#[test]
fn provider_stream_failure_preserves_typed_liveness_fields() {
    let failure = VmError::ProviderStreamFailure(Box::new(crate::value::ProviderStreamFailure {
        provider: "openai".to_string(),
        phase: crate::value::ProviderStreamPhase::Streaming,
        reason: crate::value::ProviderStreamFailureReason::Deadline,
        deadline: Some(crate::value::ProviderStreamDeadline::Idle),
        partial: true,
        detail: "idle deadline elapsed".to_string(),
    }));

    let dict = super::call::build_llm_error_dict(&failure, "openai", "test-model");

    assert_eq!(field(&dict, "category").as_deref(), Some("timeout"));
    assert_eq!(field(&dict, "kind").as_deref(), Some("transient"));
    assert_eq!(field(&dict, "source").as_deref(), Some("provider_stream"));
    assert_eq!(field(&dict, "phase").as_deref(), Some("streaming"));
    assert_eq!(field(&dict, "deadline").as_deref(), Some("idle"));
    assert_eq!(field(&dict, "partial").as_deref(), Some("true"));
}

#[test]
fn preserves_route_recorded_by_a_routing_failure() {
    let thrown = VmError::Thrown(VmValue::dict([
        ("kind", VmValue::String(arcstr::ArcStr::from("terminal"))),
        (
            "reason",
            VmValue::String(arcstr::ArcStr::from("provider_exhausted")),
        ),
        (
            "provider",
            VmValue::String(arcstr::ArcStr::from("backup-provider")),
        ),
        (
            "model",
            VmValue::String(arcstr::ArcStr::from("escalated-model")),
        ),
    ]));

    let dict = super::call::build_llm_error_dict(&thrown, "base-provider", "base-model");

    assert_eq!(field(&dict, "provider").as_deref(), Some("backup-provider"));
    assert_eq!(field(&dict, "model").as_deref(), Some("escalated-model"));
}

#[test]
fn fills_route_when_the_failure_did_not_record_one() {
    let thrown = VmError::Thrown(VmValue::dict([(
        "reason",
        VmValue::String(arcstr::ArcStr::from("timeout")),
    )]));

    let dict = super::call::build_llm_error_dict(&thrown, "base-provider", "base-model");

    assert_eq!(field(&dict, "provider").as_deref(), Some("base-provider"));
    assert_eq!(field(&dict, "model").as_deref(), Some("base-model"));
}

#[test]
fn no_single_route_failure_is_not_backfilled_with_the_base_route() {
    let thrown = VmError::Thrown(VmValue::dict([
        (
            "reason",
            VmValue::String(arcstr::ArcStr::from("provider_exhausted")),
        ),
        ("no_single_route", VmValue::Bool(true)),
    ]));

    let dict = super::call::build_llm_error_dict(&thrown, "base-provider", "base-model");

    assert!(
        field(&dict, "provider").is_none(),
        "composite failure must not be backfilled with the base provider"
    );
    assert!(
        field(&dict, "model").is_none(),
        "composite failure must not be backfilled with the base model"
    );
}