errand-bot 0.1.0

Run a coding agent from a chat channel, in a sandbox it cannot escape.
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! Tests for model selection, ported from `model_test.ts`.

use std::collections::BTreeMap;

use super::{expand_alias, resolve_model, select_model};

fn aliases(entries: &[(&str, &str)]) -> BTreeMap<String, String> {
    entries
        .iter()
        .map(|(name, target)| ((*name).to_owned(), (*target).to_owned()))
        .collect()
}

#[test]
fn a_leading_model_flag_is_read_off_and_the_prompt_keeps_the_rest() {
    assert_eq!(
        select_model("--model meta/muse-spark-1.3-contributor:max build it"),
        super::ModelSelection {
            value: Some("meta/muse-spark-1.3-contributor:max".to_owned()),
            prompt: "build it".to_owned(),
        }
    );
    // Both spellings, because a person writes whichever they are used to.
    assert_eq!(
        select_model("--model=glm-5.3 go"),
        super::ModelSelection {
            value: Some("glm-5.3".to_owned()),
            prompt: "go".to_owned(),
        }
    );
    // A flag with nothing after it selects nothing and stays in the prompt.
    assert_eq!(
        select_model("just do the thing"),
        super::ModelSelection {
            value: None,
            prompt: "just do the thing".to_owned(),
        }
    );
}

/// A prompt that talks about the flag must not be taken as using it.
#[test]
fn a_model_flag_is_only_an_instruction_at_the_very_start() {
    assert_eq!(
        select_model("explain --model to me"),
        super::ModelSelection {
            value: None,
            prompt: "explain --model to me".to_owned(),
        }
    );
}

#[test]
fn a_known_leading_segment_is_the_provider_anything_else_is_the_model() {
    let known = ["zai-coding-cn", "meta"];
    // Named provider, and the model keeps its own slash and thinking level.
    assert_eq!(
        resolve_model("meta/muse-spark-1.3-contributor:max", &known),
        super::ChosenModel {
            provider: Some("meta".to_owned()),
            model: "muse-spark-1.3-contributor:max".to_owned(),
        }
    );
    // A model id that merely contains a slash is not a provider.
    assert_eq!(
        resolve_model("meta/muse-spark-1.3-contributor", &["openrouter"]),
        super::ChosenModel {
            provider: None,
            model: "meta/muse-spark-1.3-contributor".to_owned(),
        }
    );
    // A plain id keeps the configured provider.
    assert_eq!(
        resolve_model("glm-5.3-flash", &known),
        super::ChosenModel {
            provider: None,
            model: "glm-5.3-flash".to_owned(),
        }
    );
}

#[test]
fn a_short_name_stands_for_the_model_it_was_given() {
    let table = aliases(&[("muse", "meta/muse-spark-1.3-contributor")]);
    assert_eq!(
        expand_alias("muse", &table),
        "meta/muse-spark-1.3-contributor"
    );
    // The level is split off before the name is looked up, then put back.
    assert_eq!(
        expand_alias("muse:xhigh", &table),
        "meta/muse-spark-1.3-contributor:xhigh"
    );
    // A name standing for nothing is left exactly as written.
    assert_eq!(expand_alias("glm-5.3-flash", &table), "glm-5.3-flash");
    assert_eq!(expand_alias("mistyped:max", &table), "mistyped:max");
}

#[test]
fn a_level_on_the_name_beats_one_written_into_the_alias() {
    let table = aliases(&[("muse", "meta/muse-spark-1.3-contributor:high")]);
    // The alias carries a default...
    assert_eq!(
        expand_alias("muse", &table),
        "meta/muse-spark-1.3-contributor:high"
    );
    // ...and being more specific replaces it rather than stacking on it.
    assert_eq!(
        expand_alias("muse:xhigh", &table),
        "meta/muse-spark-1.3-contributor:xhigh"
    );
}

/// A colon in a model id must not be read as a thinking level.
#[test]
fn only_a_real_level_is_split_off_the_end() {
    let table = aliases(&[("weird", "provider/model:batch")]);
    assert_eq!(expand_alias("weird", &table), "provider/model:batch");
    assert_eq!(
        expand_alias("weird:max", &table),
        "provider/model:batch:max"
    );
}

/// Naming the model is typed often enough to be worth a short form.
#[test]
fn short_m_is_the_same_flag_as_the_long_one() {
    assert_eq!(
        select_model("-m musecringe:xhigh build it"),
        super::ModelSelection {
            value: Some("musecringe:xhigh".to_owned()),
            prompt: "build it".to_owned(),
        }
    );
    assert_eq!(
        select_model("-m=glm go"),
        super::ModelSelection {
            value: Some("glm".to_owned()),
            prompt: "go".to_owned(),
        }
    );

    // Still only at the very start, and still a whole word: a prompt about a
    // flag, and a word that merely begins with it, are left alone.
    assert_eq!(
        select_model("run it with -m glm"),
        super::ModelSelection {
            value: None,
            prompt: "run it with -m glm".to_owned(),
        }
    );
    assert_eq!(
        select_model("-make the thing"),
        super::ModelSelection {
            value: None,
            prompt: "-make the thing".to_owned(),
        }
    );
    assert_eq!(
        select_model("-m"),
        super::ModelSelection {
            value: None,
            prompt: "-m".to_owned(),
        }
    );
}