kcode-k1-chat-thread-actions 0.2.0

Synchronous CurrentTime dispatch for K1 chat threads
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

use kcode_k1_chat_chatend::{ActionId, BoxContent, Chatend, DispatchCall, DispatchOutcome};

use super::dispatch;

fn action(sequence: u64) -> ActionId {
    ActionId::new([sequence as u8; 12], sequence)
}

fn calls(chat: &mut Chatend, specs: &[(&str, &str)]) -> Vec<DispatchCall> {
    chat.start_round().unwrap();
    for (name, arguments) in specs {
        chat.collect_provider_call((*name).into(), (*arguments).into())
            .unwrap();
    }
    let actions = (1..=specs.len() as u64).map(action).collect::<Vec<_>>();
    chat.complete_provider_output(&actions).unwrap()
}

fn terminal(outcome: &DispatchOutcome) -> &Result<String, String> {
    let DispatchOutcome::Terminal(result) = outcome else {
        panic!("dispatch must not return pending");
    };
    result
}

#[test]
fn current_time_call_returns_matching_return() {
    let mut chat = Chatend::new();
    let calls = calls(&mut chat, &[("CurrentTime", "{}")]);
    let call = calls[0].clone();
    let outcomes = dispatch(&calls);

    assert!(
        terminal(&outcomes[0])
            .as_ref()
            .is_ok_and(|time| !time.is_empty())
    );
    chat.complete_dispatch(outcomes).unwrap();
    assert!(matches!(
        chat.boxes().last().unwrap().content(),
        BoxContent::KtoolReturn {
            action_id,
            originating_call,
            result: Ok(_),
        } if *action_id == call.action_id && *originating_call == call.call_box_id
    ));
}

#[test]
fn calls_and_returns_preserve_order() {
    let mut chat = Chatend::new();
    let calls = calls(
        &mut chat,
        &[("CurrentTime", "{}"), ("CurrentTime", " { } ")],
    );
    let outcomes = dispatch(&calls);

    assert!(outcomes.iter().all(|outcome| terminal(outcome).is_ok()));
    chat.complete_dispatch(outcomes).unwrap();
    let boxes = chat.boxes();
    assert!(
        matches!(boxes[1].content(), BoxContent::KtoolCall { action_id, .. } if *action_id == calls[0].action_id)
    );
    assert!(
        matches!(boxes[2].content(), BoxContent::KtoolCall { action_id, .. } if *action_id == calls[1].action_id)
    );
    assert!(
        matches!(boxes[3].content(), BoxContent::KtoolReturn { action_id, .. } if *action_id == calls[0].action_id)
    );
    assert!(
        matches!(boxes[4].content(), BoxContent::KtoolReturn { action_id, .. } if *action_id == calls[1].action_id)
    );
}

#[test]
fn invalid_and_unknown_calls_remain_and_return_one_error_each() {
    let cases = ["", "null", "[]", "{\"zone\":\"UTC\"}"];
    for arguments in cases {
        let mut chat = Chatend::new();
        let calls = calls(&mut chat, &[("CurrentTime", arguments)]);
        let call_box = chat.boxes()[1].clone();
        let outcomes = dispatch(&calls);
        assert_eq!(
            terminal(&outcomes[0]),
            &Err("invalid CurrentTime arguments".into())
        );
        chat.complete_dispatch(outcomes).unwrap();
        assert_eq!(chat.boxes()[1], call_box);
        assert!(
            matches!(chat.boxes()[2].content(), BoxContent::KtoolReturn { result: Err(error), .. } if error == "invalid CurrentTime arguments")
        );
    }

    let mut chat = Chatend::new();
    let calls = calls(&mut chat, &[("NoSuchTool", "{}")]);
    let outcomes = dispatch(&calls);
    assert_eq!(terminal(&outcomes[0]), &Err("unknown Ktool".into()));
    chat.complete_dispatch(outcomes).unwrap();
    assert!(
        matches!(chat.boxes()[2].content(), BoxContent::KtoolReturn { result: Err(error), .. } if error == "unknown Ktool")
    );
}

#[test]
fn queued_user_drains_after_synchronous_returns_and_calls_stay_immutable() {
    let mut chat = Chatend::new();
    let calls = calls(&mut chat, &[("CurrentTime", "{}"), ("NoSuchTool", "{}")]);
    let call_boxes = chat.boxes()[1..3].to_vec();
    assert!(
        chat.accept_user("arrived during dispatch".into())
            .unwrap()
            .is_none()
    );

    chat.complete_dispatch(dispatch(&calls)).unwrap();
    assert_eq!(&chat.boxes()[1..3], call_boxes.as_slice());
    assert!(matches!(
        chat.boxes()[3].content(),
        BoxContent::KtoolReturn { .. }
    ));
    assert!(matches!(
        chat.boxes()[4].content(),
        BoxContent::KtoolReturn { .. }
    ));
    assert!(
        matches!(chat.boxes()[5].content(), BoxContent::User(text) if text == "arrived during dispatch")
    );
}