harn-vm 0.10.153

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use super::extract::extract_llm_options;
use super::routing_test_support::one_tool_list;
use crate::value::VmValue;

fn text_channel_options(tool_format: &str, contract_rendered: bool) -> crate::value::DictMap {
    let mut options = crate::value::DictMap::from_iter([
        (
            crate::value::intern_key("provider"),
            VmValue::String(arcstr::ArcStr::from("local")),
        ),
        (
            crate::value::intern_key("model"),
            VmValue::String(arcstr::ArcStr::from("text-channel-model")),
        ),
        (
            crate::value::intern_key("tool_format"),
            VmValue::String(arcstr::ArcStr::from(tool_format)),
        ),
        (crate::value::intern_key("tools"), one_tool_list()),
    ]);
    if contract_rendered {
        options.insert(
            crate::value::intern_key("_tool_contract_rendered"),
            VmValue::Bool(true),
        );
    }
    options
}

/// A direct call with text-channel tools sends no schemas and no contract, so
/// the model is never told a tool exists. It must refuse, not dispatch.
#[test]
fn a_direct_call_with_text_channel_tools_is_refused() {
    crate::llm::capabilities::clear_user_overrides();
    crate::llm_config::clear_user_overrides();
    crate::llm::capabilities::set_user_overrides_toml(
        r#"
[[provider.local]]
model_match = "text-channel-model"
native_tools = true
preferred_tool_format = "text"
text_tool_wire_format_supported = true
"#,
    )
    .expect("text-channel capability override");
    for tool_format in ["json", "text"] {
        let refused = extract_llm_options(&[
            VmValue::String(arcstr::ArcStr::from("hello")),
            VmValue::Nil,
            VmValue::dict(text_channel_options(tool_format, false)),
        ]);
        let message = match refused {
            Err(crate::value::VmError::Thrown(VmValue::Dict(fields))) => fields
                .get("message")
                .map(VmValue::display)
                .unwrap_or_default(),
            Err(other) => format!("{other:?}"),
            Ok(_) => panic!("tool_format {tool_format}: a direct call with tools must be refused"),
        };
        assert!(
            message.contains("agent_loop") && message.contains("tool_format: \"native\""),
            "tool_format {tool_format}: {message}"
        );
        // Negative control: the agent loop's own call renders the contract.
        let accepted = extract_llm_options(&[
            VmValue::String(arcstr::ArcStr::from("hello")),
            VmValue::Nil,
            VmValue::dict(text_channel_options(tool_format, true)),
        ]);
        assert!(
            accepted.is_ok(),
            "tool_format {tool_format}: the loop-marked call must be accepted: {:?}",
            accepted.err()
        );
    }
    crate::llm::capabilities::clear_user_overrides();
}

#[test]
fn text_tool_format_does_not_emit_native_provider_tools() {
    crate::llm::capabilities::clear_user_overrides();
    crate::llm_config::clear_user_overrides();

    let options = crate::value::DictMap::from_iter([
        (
            crate::value::intern_key("provider"),
            VmValue::String(arcstr::ArcStr::from("ollama".to_string())),
        ),
        (
            crate::value::intern_key("model"),
            VmValue::String(arcstr::ArcStr::from("devstral-small-2:24b".to_string())),
        ),
        (
            crate::value::intern_key("tool_format"),
            VmValue::String(arcstr::ArcStr::from("text".to_string())),
        ),
        (crate::value::intern_key("tools"), one_tool_list()),
        // The agent loop's call, which renders the text contract.
        (
            crate::value::intern_key("_tool_contract_rendered"),
            VmValue::Bool(true),
        ),
    ]);
    let opts = extract_llm_options(&[
        VmValue::String(arcstr::ArcStr::from("hello".to_string())),
        VmValue::Nil,
        VmValue::dict(options),
    ])
    .expect("text-format tools accepted");

    assert!(opts.tools.is_some());
    assert!(opts.native_tools.is_none());
}