vtcode-llm 0.181.0

LLM provider abstraction, client implementations, and streaming for VT Code
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use super::{AssistantPhase, ContentPart, ImageDetail, Message, MessageClearAt, MessageContent, MessageRole, ToolCall};

#[test]
fn message_content_parts_concatenate_without_extra_spaces() {
    let parts = vec![
        ContentPart::text("Andre".to_string()),
        ContentPart::text("j".to_string()),
        ContentPart::text(" Kar".to_string()),
        ContentPart::text("pathy".to_string()),
        ContentPart::text("'s".to_string()),
    ];
    let content = MessageContent::Parts(parts);

    assert_eq!(content.as_text().as_ref() as &str, "Andrej Karpathy's");
}

#[test]
fn message_content_parts_with_single_text_stays_borrowed() {
    let content = MessageContent::Parts(vec![ContentPart::text("borrowed".to_string())]);

    assert!(matches!(content.as_text(), std::borrow::Cow::Borrowed("borrowed")));
}

#[test]
fn message_content_parts_without_text_stays_borrowed_empty() {
    let content = MessageContent::Parts(vec![ContentPart::image("encoded".to_string(), "image/png".to_string())]);

    assert!(matches!(content.as_text(), std::borrow::Cow::Borrowed("")));
}

#[test]
fn assistant_phase_parses_wire_strings() {
    assert_eq!(AssistantPhase::from_wire_str("commentary"), Some(AssistantPhase::Commentary));
    assert_eq!(AssistantPhase::from_wire_str("final_answer"), Some(AssistantPhase::FinalAnswer));
    assert_eq!(AssistantPhase::from_wire_str("other"), None);
}

/// `AssistantPhase` exposes the same value through the derived serde wire
/// form, `as_str()`, and `from_wire_str()`. Lock all three so a one-sided
/// edit cannot desync the persisted phase from the wire parser.
#[test]
fn assistant_phase_string_paths_stay_in_lockstep() {
    for phase in [AssistantPhase::Commentary, AssistantPhase::FinalAnswer] {
        let expected = phase.as_str();
        assert_eq!(
            serde_json::to_value(phase).expect("serializes"),
            serde_json::json!(expected),
            "serde form drifted for {phase:?}"
        );
        assert_eq!(AssistantPhase::from_wire_str(expected), Some(phase), "from_wire_str drift");
    }
}

/// `ImageDetail` mirrors its `#[serde(rename)]` values in `as_str()` and
/// `from_str()`; lock them together.
#[test]
fn image_detail_string_paths_stay_in_lockstep() {
    for detail in [
        ImageDetail::Low,
        ImageDetail::High,
        ImageDetail::Original,
        ImageDetail::Auto,
    ] {
        let expected = detail.as_str();
        assert_eq!(
            serde_json::to_value(&detail).expect("serializes"),
            serde_json::json!(expected),
            "serde form drifted for {detail:?}"
        );
        assert_eq!(ImageDetail::from_str(expected), Some(detail), "from_str drift");
    }
}

#[test]
fn with_phase_ignores_non_assistant_roles() {
    let user = Message::user("hello".to_string()).with_phase(Some(AssistantPhase::Commentary));
    let tool =
        Message::tool_response("call_1".to_string(), "ok".to_string()).with_phase(Some(AssistantPhase::FinalAnswer));

    assert_eq!(user.role, MessageRole::User);
    assert!(user.phase.is_none());
    assert_eq!(tool.role, MessageRole::Tool);
    assert!(tool.phase.is_none());
}

#[test]
fn turn_scoped_system_message_round_trips_clear_scope() {
    let message = Message::turn_scoped_system("Only you see the output".to_string());
    let encoded = serde_json::to_value(&message).expect("message serialization");

    assert_eq!(encoded["role"], "System");
    assert_eq!(encoded["clear_at"], "next_user_message");
    assert_eq!(message.clear_at, Some(MessageClearAt::NextUserMessage));
    assert_eq!(serde_json::from_value::<Message>(encoded).expect("message deserialization"), message);
}

#[test]
fn turn_scoped_system_message_requires_non_anthropic_wire_translation() {
    let error = Message::turn_scoped_system("notice".to_string())
        .validate_for_provider("openai")
        .expect_err("raw Anthropic lifecycle fields are not valid on an OpenAI wire");
    assert!(error.contains("only supported by Anthropic"));
}

#[test]
fn validate_for_provider_accepts_recovered_tool_arguments() {
    let message = Message::assistant_with_tools(
        String::new(),
        vec![ToolCall::function(
            "call_search".to_string(),
            "code_search".to_string(),
            "{\"query\": \"persistent_memory\", \"path\": \"crates/codegen/vtcode-core/src</parameter>\n<</invoke>\n</minimax:tool_call>".to_string(),
        )],
    );

    message.validate_for_provider("anthropic").unwrap();
}

#[test]
fn validate_for_provider_requires_tool_call_id_for_meta() {
    let message = Message {
        role: MessageRole::Tool,
        content: MessageContent::text("result".to_owned()),
        ..Default::default()
    };

    let error = message
        .validate_for_provider("meta")
        .expect_err("Meta tool messages need an id");
    assert!(error.contains("tool_call_id"));
}