opencrabs 0.5.1

The autonomous, self-improving AI agent. Single Rust binary. Every channel. Recommended: the 40MB prebuilt binary for macOS, Linux and Windows: https://github.com/adolfousier/opencrabs/releases
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

//! `*_provider` key normalisation (#1314, #1316): the `custom:` table path is
//! not part of the provider name, a `<provider>/<model>` pair is split only
//! when the head is a provider the user actually configured, and the note
//! names the key it corrected. Fixtures are synthetic; no keys or user
//! identifiers.

use crate::brain::provider_spec::{ProviderKey, ProviderPair, normalize};

const RSI: ProviderKey = ProviderKey::SELF_IMPROVEMENT;

fn custom(name: &str) -> bool {
    matches!(name, "glm-53-max" | "moonshotai")
}

fn declared(name: &str) -> bool {
    custom(name) || matches!(name, "zhipu" | "minimax")
}

#[test]
fn a_bare_provider_name_is_untouched_and_unnoted() {
    let p = normalize(RSI, "moonshotai", None, custom, declared);
    assert_eq!(
        p,
        ProviderPair {
            provider: "moonshotai".into(),
            model: None,
            note: None
        }
    );
}

#[test]
fn the_custom_prefix_is_dropped_in_every_spelling() {
    for spec in [
        "custom:glm-53-max",
        "custom.glm-53-max",
        "custom/glm-53-max",
        " custom:glm-53-max ",
    ] {
        let p = normalize(RSI, spec, None, custom, declared);
        assert_eq!(p.provider, "glm-53-max", "{spec}");
        assert_eq!(p.model, None, "{spec}");
        let note = p.note.expect(spec);
        assert!(note.contains("write \"glm-53-max\""), "{note}");
    }
}

#[test]
fn a_declared_provider_slash_model_is_split() {
    for spec in ["zhipu/glm-5.3", "zhipu:glm-5.3"] {
        let p = normalize(RSI, spec, None, custom, declared);
        assert_eq!(p.provider, "zhipu", "{spec}");
        assert_eq!(p.model.as_deref(), Some("glm-5.3"), "{spec}");
        assert!(p.note.unwrap().contains("self_improvement_model"), "{spec}");
    }
}

#[test]
fn a_custom_prefix_and_a_model_are_both_corrected() {
    let p = normalize(RSI, "custom:moonshotai/kimi-k2", None, custom, declared);
    assert_eq!(p.provider, "moonshotai");
    assert_eq!(p.model.as_deref(), Some("kimi-k2"));
    let note = p.note.unwrap();
    assert!(note.contains("dropped the 'custom:' prefix"), "{note}");
    assert!(note.contains("split"), "{note}");
}

#[test]
fn an_unknown_head_is_not_split_because_model_ids_carry_separators() {
    // "anthropic" is not declared in this fixture: an openrouter-style id
    // must not be torn apart into a phantom provider.
    let p = normalize(RSI, "anthropic/claude-opus-5", None, custom, declared);
    assert_eq!(p.provider, "anthropic/claude-opus-5");
    assert_eq!(p.model, None);
    assert_eq!(p.note, None);
}

#[test]
fn the_explicit_model_key_wins_over_a_model_in_the_spec() {
    let p = normalize(RSI, "zhipu/glm-5.3", Some("glm-5.3-air"), custom, declared);
    assert_eq!(p.provider, "zhipu");
    assert_eq!(p.model.as_deref(), Some("glm-5.3-air"));
    assert!(
        p.note.unwrap().contains("wins over"),
        "explicit key must be named"
    );

    // Same model in both places is not a disagreement worth a note line.
    let same = normalize(RSI, "zhipu/glm-5.3", Some("glm-5.3"), custom, declared);
    assert_eq!(same.model.as_deref(), Some("glm-5.3"));
    assert!(!same.note.unwrap().contains("wins over"));
}

#[test]
fn an_empty_model_key_counts_as_unset() {
    let p = normalize(RSI, "minimax", Some("  "), custom, declared);
    assert_eq!(p.model, None);
    assert_eq!(p.note, None);
}

#[test]
fn the_note_names_the_key_it_corrected() {
    let p = normalize(
        ProviderKey::SUBAGENT,
        "zhipu/glm-5.3",
        Some("glm-5.3-air"),
        custom,
        declared,
    );
    let note = p.note.unwrap();
    assert!(
        note.contains("subagent_provider takes a provider name only"),
        "{note}"
    );
    assert!(
        note.contains("subagent_model = \"glm-5.3-air\" wins"),
        "{note}"
    );
    assert!(!note.contains("self_improvement"), "{note}");
}