harn-vm 0.8.83

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

use super::output::*;
use super::*;

#[test]
fn parses_explicit_json_schema_output_format() {
    let mut fmt = BTreeMap::new();
    fmt.insert(
        "kind".to_string(),
        VmValue::String(std::sync::Arc::from("json_schema")),
    );
    fmt.insert(
        "schema".to_string(),
        VmValue::Dict(std::sync::Arc::new(BTreeMap::from([(
            "type".to_string(),
            VmValue::String(std::sync::Arc::from("object")),
        )]))),
    );
    fmt.insert("strict".to_string(), VmValue::Bool(false));
    let options = BTreeMap::from([(
        "output_format".to_string(),
        VmValue::Dict(std::sync::Arc::new(fmt)),
    )]);

    let parsed = parse_output_format_option(Some(&options), None, None).expect("output_format");

    assert_eq!(
        parsed,
        crate::llm::api::OutputFormat::JsonSchema {
            schema: serde_json::json!({"type": "object"}),
            strict: false,
        }
    );
}

#[test]
fn legacy_response_format_and_json_schema_map_to_typed_output_format() {
    let schema = serde_json::json!({"type": "object"});

    let parsed = parse_output_format_option(Some(&BTreeMap::new()), Some("json"), Some(&schema))
        .expect("legacy output format");

    assert_eq!(
        parsed,
        crate::llm::api::OutputFormat::JsonSchema {
            schema,
            strict: true,
        }
    );
}

#[test]
fn rejects_json_schema_when_capability_is_absent() {
    crate::llm::capabilities::clear_user_overrides();
    let err = validate_output_format_supported(
        &crate::llm::api::OutputFormat::JsonSchema {
            schema: serde_json::json!({"type": "object"}),
            strict: true,
        },
        "custom-provider",
        "custom-model",
        &crate::llm::capabilities::lookup("custom-provider", "custom-model"),
    )
    .expect_err("unsupported structured output should fail");

    assert!(err
        .to_string()
        .contains("option `output_format` is not supported by `custom-model`"));
}

#[test]
fn accepts_json_schema_when_capability_declares_strategy() {
    crate::llm::capabilities::set_user_overrides_toml(
        r#"
[[provider.custom-provider]]
model_match = "*"
structured_output = "format_kw"
"#,
    )
    .expect("capability override");

    validate_output_format_supported(
        &crate::llm::api::OutputFormat::JsonSchema {
            schema: serde_json::json!({"type": "object"}),
            strict: true,
        },
        "custom-provider",
        "custom-model",
        &crate::llm::capabilities::lookup("custom-provider", "custom-model"),
    )
    .expect("supported structured output");
    crate::llm::capabilities::clear_user_overrides();
}