vtcode-core 0.175.5

Core library for VT Code - a Rust-based terminal coding agent
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

use super::*;

#[tokio::test]
async fn local_summary_fork_omits_clear_at_for_gateway_routes() {
    use super::compact_history_manual_with_parent_context;

    let history = vec![
        Message::user("do the thing".to_string()),
        Message::turn_scoped_system("collapsed output notice".to_string()),
        Message::user("continue".to_string()),
    ];
    let config = CompactionConfig {
        always_summarize: true,
        ..CompactionConfig::default()
    };
    // CapturingProvider uses the trait default
    // `supports_turn_scoped_system_messages == false`, like merge-gateway.
    let provider = CapturingProvider { last_request: Mutex::new(None) };
    let (compacted, mode) = compact_history_manual_with_parent_context(
        &provider,
        "openai/gpt-6-luna",
        &history,
        &config,
        &ManualCompactionOptions::default(),
        None,
        None,
    )
    .await
    .expect("gateway local compaction must succeed");
    assert_eq!(mode, CompactionMode::Local);
    let captured = provider.last_request.lock().unwrap().clone().expect("captured request");
    assert!(
        captured.messages.iter().all(|message| message.clear_at.is_none()),
        "gateway summary fork must not carry clear_at"
    );
    assert!(
        captured
            .messages
            .iter()
            .any(|message| message.content.as_text().as_ref() == "collapsed output notice"),
        "collapsed notice text must survive as ordinary directive"
    );
    assert!(!compacted.is_empty());
}

#[tokio::test]
async fn manual_compaction_with_parent_context_reuses_prefix() {
    use super::{CompactionParentContext, compact_history_manual_with_parent_context};

    let history = sample_history();
    let config = CompactionConfig {
        always_summarize: true,
        ..CompactionConfig::default()
    };
    let provider = CapturingProvider { last_request: Mutex::new(None) };
    let parent = CompactionParentContext {
        system_prompt: Some(Arc::from("parent system")),
        tools: None,
    };
    let (compacted, mode) = compact_history_manual_with_parent_context(
        &provider,
        "stub-model",
        &history,
        &config,
        &ManualCompactionOptions::default(),
        None,
        Some(&parent),
    )
    .await
    .expect("parent-aware compaction");
    assert_eq!(mode, CompactionMode::Local);
    let captured = provider.last_request.lock().unwrap().clone().expect("captured request");
    assert_eq!(captured.system_prompt.as_deref(), Some("parent system"));
    assert_eq!(captured.messages.len(), history.len() + 1);
    assert_eq!(compacted[0].content.as_text(), "Previous conversation summary:\nsummary");
}

#[tokio::test]
async fn hierarchical_bands_reuse_parent_prefix_without_tool_calls() {
    use super::{CompactionParentContext, compact_history_manual_with_parent_context};

    let history = (0..12)
        .map(|index| Message::user(format!("hierarchical request {index}")))
        .collect::<Vec<_>>();
    let config = CompactionConfig {
        always_summarize: true,
        hierarchical: true,
        ..CompactionConfig::default()
    };
    let provider = CapturingProvider { last_request: Mutex::new(None) };
    let parent = CompactionParentContext {
        system_prompt: Some(Arc::from("parent system")),
        tools: None,
    };
    let (compacted, mode) = compact_history_manual_with_parent_context(
        &provider,
        "stub-model",
        &history,
        &config,
        &ManualCompactionOptions::default(),
        None,
        Some(&parent),
    )
    .await
    .expect("hierarchical compaction");
    assert_eq!(mode, CompactionMode::Local);
    // CapturingProvider keeps the last request, which is the detail band.
    let captured = provider.last_request.lock().unwrap().clone().expect("captured detail request");
    assert_eq!(captured.system_prompt.as_deref(), Some("parent system"));
    assert!(matches!(captured.tool_choice, Some(crate::llm::provider::ToolChoice::None)));
    assert!(!compacted.is_empty());
}