harn-vm 0.10.170

Async bytecode virtual machine for the Harn programming language
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Native option-selection provenance for provider-confirmed reasoning effort.

#[cfg(test)]
use harn_llm::effective_effort::EffectiveReasoningEffort;
use harn_llm::effective_effort::ReasoningEffortSource;

pub(crate) fn request_source(opts: &crate::llm::api::LlmCallOptions) -> ReasoningEffortSource {
    if opts
        .provider_overrides
        .as_ref()
        .and_then(|v| v.pointer("/reasoning/effort"))
        .is_some()
    {
        ReasoningEffortSource::Operator
    } else {
        match opts
            .resolution
            .iter()
            .find(|row| row.setting == "reasoning")
            .map(|row| row.source)
        {
            Some("caller.effort" | "caller.thinking") => ReasoningEffortSource::Operator,
            Some("catalog.model_defaults.reasoning_effort") => ReasoningEffortSource::Catalog,
            Some("reasoning_policy") => ReasoningEffortSource::Policy,
            _ => ReasoningEffortSource::Request,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn public_effort_types_and_selection_provenance_agree() {
        use harn_parser::builtin_signatures::TyExt;
        use harn_parser::{Node, TypeExpr};
        let declarations = harn_parser::parse_source(
            harn_modules::stdlib_catalog()
                .source("llm/envelope")
                .expect("embedded envelope"),
        )
        .expect("envelope parses");
        let alias = |name: &str| {
            declarations
                .iter()
                .find_map(|node| match &node.node {
                    Node::TypeDecl {
                        name: declared,
                        type_expr,
                        ..
                    } if declared == name => Some(type_expr.clone()),
                    _ => None,
                })
                .expect("public alias")
        };
        let sources = alias("ReasoningEffortSource");
        assert_eq!(
            sources,
            harn_builtin_meta::shapes::REASONING_EFFORT_SOURCE.to_type_expr()
        );
        let mut observation = alias("EffectiveReasoningEffort");
        let TypeExpr::Union(variants) = &mut observation else {
            panic!("observation must be a union")
        };
        for variant in variants {
            let TypeExpr::Shape(fields) = variant else {
                panic!("observation arms must be closed records")
            };
            for field in fields {
                if field.name == "source" {
                    assert_eq!(
                        field.type_expr,
                        TypeExpr::Named("ReasoningEffortSource".into())
                    );
                    field.type_expr = sources.clone();
                }
            }
        }
        assert_eq!(
            observation,
            harn_builtin_meta::shapes::EFFECTIVE_REASONING_EFFORT.to_type_expr()
        );
        for (resolved_source, expected) in [
            ("caller.effort", ReasoningEffortSource::Operator),
            ("caller.thinking", ReasoningEffortSource::Operator),
            (
                "catalog.model_defaults.reasoning_effort",
                ReasoningEffortSource::Catalog,
            ),
            ("reasoning_policy", ReasoningEffortSource::Policy),
            ("unset", ReasoningEffortSource::Request),
        ] {
            let mut opts = crate::llm::api::options::base_opts("openai");
            opts.resolution.push(crate::llm::api::ResolvedSetting {
                setting: "reasoning",
                source: resolved_source,
                ..Default::default()
            });
            let mut observation = EffectiveReasoningEffort::Reported {
                level: "high".into(),
                source: ReasoningEffortSource::Request,
            };
            observation.resolve_source(request_source(&opts));
            assert_eq!(
                observation,
                EffectiveReasoningEffort::Reported {
                    level: "high".into(),
                    source: expected
                }
            );
        }
    }
}