ai-dispatch 10.33.0

Multi-AI CLI team orchestrator
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

use super::*;

/// The two shapes that broke routing on 2026-08-05 must stay distinguishable.
/// agy metering per family is why marking the whole CLI stranded a working
/// claude allowance; qwen's single pool is why marking one of its 17 models
/// would have been wrong in the opposite direction.
#[test]
fn the_shapes_that_broke_routing_are_distinct() {
    let (agy, agy_shape) = provider_for_cli(AgentKind::Antigravity);
    let (qwen, qwen_shape) = provider_for_cli(AgentKind::Qwen);
    assert_eq!(agy_shape, MeteringShape::PerModelFamily);
    assert_eq!(qwen_shape, MeteringShape::AccountPool);
    assert_ne!(agy, qwen);
}

/// A spend budget is not a time window. opencode Zen refuses with
/// "Insufficient balance" and only a top-up clears it, so treating it as an
/// account pool would have aid waiting for a reset that never comes.
#[test]
fn a_spend_budget_is_not_a_time_windowed_pool() {
    let (_, shape) = provider_for_cli(AgentKind::OpenCode);
    assert_eq!(shape, MeteringShape::SpendBudget);
}

/// Providers nobody has observed refusing stay unknown. The point of the
/// dimension is to stop recording plausible values that were never established.
#[test]
fn unobserved_providers_are_unknown_not_invented() {
    for cli in [AgentKind::Kilo, AgentKind::MiMoCode, AgentKind::Custom] {
        let (provider, shape) = provider_for_cli(cli);
        assert!(provider.is_unknown(), "{} must not be given an invented provider", cli.as_str());
        assert_eq!(shape, MeteringShape::Unknown);
    }
}

/// aidbar's GetGrokCreditsConfig is one billing-period pool: used_percent plus
/// period_end. That is AccountPool, not an invented unknown.
#[test]
fn grok_is_an_account_pool() {
    let (provider, shape) = provider_for_cli(AgentKind::Grok);
    assert_eq!(provider.as_str(), "xai");
    assert!(!provider.is_unknown());
    assert_eq!(shape, MeteringShape::AccountPool);
}

#[test]
fn commandcode_is_its_own_provider() {
    let (provider, shape) = provider_for_cli(AgentKind::CommandCode);
    assert_eq!(provider.as_str(), "commandcode.ai");
    assert!(!provider.is_unknown());
    assert_eq!(shape, MeteringShape::Unknown);
}

/// Two CLIs from the same vendor must not collapse into one provider: agy and
/// gemini both reach Google models, but an exhausted Antigravity tier says
/// nothing about a Gemini API key.
#[test]
fn one_vendor_two_cli_routes_are_two_providers() {
    let (agy, _) = provider_for_cli(AgentKind::Antigravity);
    let (gemini, _) = provider_for_cli(AgentKind::Gemini);
    assert_ne!(agy, gemini);
}

/// Every built-in CLI is third-party or unknown. None of them are local: the
/// CLI binary running on the laptop does not make the provider local.
#[test]
fn no_builtin_cli_is_local_egress() {
    for cli in AgentKind::ALL_BUILTIN {
        let tier = egress_for_cli(*cli);
        assert!(
            !tier.admits_local(),
            "{} must not admit --egress local (got {})",
            cli.as_str(),
            tier.label()
        );
    }
}

/// Local is established only by a loopback base_url, never by a provider name.
#[test]
fn only_loopback_base_url_is_local() {
    assert_eq!(egress_for_base_url("http://127.0.0.1:11434/v1"), EgressTier::Local);
    assert_eq!(egress_for_base_url("http://127.0.0.2/v1"), EgressTier::Local);
    assert_eq!(egress_for_base_url("http://localhost:8080/v1"), EgressTier::Local);
    assert_eq!(egress_for_base_url("http://[::1]:8080/v1"), EgressTier::Local);
    assert_eq!(
        egress_for_base_url("https://token-plan-sgp.xiaomimimo.com/v1"),
        EgressTier::ThirdParty
    );
    assert_eq!(egress_for_base_url(""), EgressTier::Unknown);
}

/// Private-network hosts are distinct from loopback and from public third-party.
#[test]
fn private_network_base_url_is_not_local_or_third_party() {
    assert_eq!(
        egress_for_base_url("http://10.0.32.184:11434/v1"),
        EgressTier::PrivateNetwork
    );
    assert_eq!(
        egress_for_base_url("http://192.168.1.50:8080/v1"),
        EgressTier::PrivateNetwork
    );
    assert!(!egress_for_base_url("http://10.0.32.184:11434/v1").admits_local());
    assert!(
        egress_for_base_url("http://10.0.32.184:11434/v1").admits_private_network()
    );
}

/// Declared custom providers are not inferred from the endpoint host.
#[test]
fn custom_provider_is_declared_not_inferred() {
    let (known, metering) = provider_for_custom(Some("ollama"), Some("none"));
    assert_eq!(known.as_str(), "ollama");
    assert_eq!(metering, MeteringShape::None);
    let (unknown, shape) = provider_for_custom(None, None);
    assert!(unknown.is_unknown());
    assert_eq!(shape, MeteringShape::Unknown);
}

/// An unknown provider is not admitted by --egress local even when a custom
/// agent config claims trust_tier = "local" by hand.
#[test]
fn unknown_provider_does_not_admit_local() {
    assert!(!egress_for_provider(&ProviderId::unknown()).admits_local());
    assert!(!egress_for_provider(&ProviderId::new("openai-chatgpt-plan")).admits_local());
}

/// Hostnames are never classified by leading characters; only parsed IPs get
/// IPv6 ULA/link-local rules.
#[test]
fn public_hostnames_with_fc_or_fd_prefix_are_third_party() {
    assert_eq!(
        egress_for_base_url("http://fc2.com/v1"),
        EgressTier::ThirdParty
    );
    assert_eq!(
        egress_for_base_url("http://fd-cdn.example.com/v1"),
        EgressTier::ThirdParty
    );
}

/// mDNS and private DNS suffixes classify as private-network, not third-party.
#[test]
fn mdns_and_home_arpa_hosts_are_private_network() {
    assert_eq!(
        egress_for_base_url("http://MingdeiMac.local:11434/v1"),
        EgressTier::PrivateNetwork
    );
    assert_eq!(
        egress_for_base_url("http://printer.home.arpa/v1"),
        EgressTier::PrivateNetwork
    );
}

/// RFC1918 boundary: 172.15 is public; 172.16–172.31 private; 172.32 public.
#[test]
fn rfc1918_172_boundary_octets() {
    assert_eq!(
        egress_for_base_url("http://172.15.255.1/v1"),
        EgressTier::ThirdParty
    );
    assert_eq!(
        egress_for_base_url("http://172.16.0.1/v1"),
        EgressTier::PrivateNetwork
    );
    assert_eq!(
        egress_for_base_url("http://172.31.255.254/v1"),
        EgressTier::PrivateNetwork
    );
    assert_eq!(
        egress_for_base_url("http://172.32.0.1/v1"),
        EgressTier::ThirdParty
    );
}

/// Parsed IPv6 ULA and link-local addresses are private-network.
#[test]
fn ipv6_ula_and_link_local_are_private_network() {
    assert_eq!(
        egress_for_base_url("http://[fc00::1]/v1"),
        EgressTier::PrivateNetwork
    );
    assert_eq!(
        egress_for_base_url("http://[fd12:3456:789a:1::1]/v1"),
        EgressTier::PrivateNetwork
    );
    assert_eq!(
        egress_for_base_url("http://[fe80::1]/v1"),
        EgressTier::PrivateNetwork
    );
}