harn-vm 0.10.180

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

use super::*;
use crate::llm::tool_conformance::ToolConformanceRequestValidationStatus;

#[test]
fn mini_probe_requests_use_responses_function_tools_and_input() {
    for mode in [ToolProbeMode::NonStreaming, ToolProbeMode::Streaming] {
        for case in [
            ToolProbeCase::SingleToolCall,
            ToolProbeCase::LargeStringArgument,
        ] {
            let expected_value = case.expected_value("mini-response-marker");
            let payload = probe_request_payload(
                "openai",
                "gpt-5.4-mini",
                mode,
                case,
                ToolProbeRequestProfile::CatalogDefault,
                &expected_value,
            )
            .expect("mini probe payload");
            assert_eq!(payload.api_mode, LlmApiMode::Responses);
            let body = provider_compatible_probe_request_body(&payload);
            assert_eq!(body["tools"][0]["type"], "function");
            assert_eq!(body["tools"][0]["name"], TOOL_PROBE_TOOL_NAME);
            assert_eq!(
                body["tools"][0]["parameters"]["properties"]["value"]["type"],
                "string"
            );
            assert_eq!(
                body["tool_choice"],
                json!({"type": "function", "name": TOOL_PROBE_TOOL_NAME})
            );
            let prompt = body["input"][0]["content"]
                .as_str()
                .expect("Responses prompt content");
            assert!(prompt.contains("mini-response-marker"));
            if case == ToolProbeCase::LargeStringArgument {
                assert!(prompt.contains("heredoc=<<EOF"));
            }
            assert!(body.get("messages").is_none());
            let validation = validate_probe_request_body(
                "openai",
                "gpt-5.4-mini",
                case,
                ToolProbeRequestProfile::CatalogDefault,
                &body,
            );
            assert_eq!(validation.dialect, "openai_responses");
            assert_eq!(
                validation.status,
                ToolConformanceRequestValidationStatus::Pass
            );
        }
    }
}

#[test]
fn mini_probe_followup_preserves_responses_call_and_output_identity() {
    let body = probe_request_body(
        "openai",
        "gpt-5.4-mini",
        ToolProbeMode::NonStreaming,
        ToolProbeCase::ToolResultFollowup,
        ToolProbeRequestProfile::CatalogDefault,
        "mini-followup-marker",
    )
    .expect("mini Responses follow-up");
    assert_eq!(body["tools"][0]["name"], TOOL_PROBE_TOOL_NAME);
    assert!(body.get("tool_choice").is_none());
    assert_eq!(body["input"].as_array().expect("Responses items").len(), 3);
    assert_eq!(body["input"][1]["type"], "function_call");
    assert_eq!(body["input"][1]["call_id"], "call_harn_tool_probe_1");
    assert_eq!(body["input"][1]["name"], TOOL_PROBE_TOOL_NAME);
    assert_eq!(body["input"][2]["type"], "function_call_output");
    assert_eq!(body["input"][2]["call_id"], "call_harn_tool_probe_1");
    let output: Value = serde_json::from_str(
        body["input"][2]["output"]
            .as_str()
            .expect("actual tool output"),
    )
    .expect("tool output JSON");
    assert_eq!(output["value"], "mini-followup-marker");
    let validation = validate_probe_request_body(
        "openai",
        "gpt-5.4-mini",
        ToolProbeCase::ToolResultFollowup,
        ToolProbeRequestProfile::CatalogDefault,
        &body,
    );
    assert_eq!(validation.dialect, "openai_responses");
    assert_eq!(
        validation.status,
        ToolConformanceRequestValidationStatus::Pass
    );
}