hatchery_node/
provider_inventory.rs

1//! Provider inventory: which provider CLIs this node can run and which models each one
2//! exposes, read from the CLI itself (or its own config). Nothing is invented: a provider whose
3//! CLI does not list models reports only what its help text / config names.
4//!
5//! - codex: `codex debug models` (JSON catalog; entries with `visibility = "list"`).
6//! - grok: `grok models` (text list; `*` marks the default).
7//! - claude: the model aliases its `--help` names for `--model`, plus `model` from
8//!   `~/.claude/settings.json`.
9//! - kimi: `[models.<alias>]` and `default_model` from `~/.kimi/config.toml`.
10
11use serde::Serialize;
12use std::io::Read;
13use std::path::{Path, PathBuf};
14use std::process::{Command, Stdio};
15use std::time::{Duration, Instant};
16
17#[derive(Clone, Debug, Serialize, PartialEq, Eq)]
18pub struct ModelInfo {
19    pub id: String,
20    #[serde(skip_serializing_if = "Vec::is_empty")]
21    pub efforts: Vec<String>,
22    #[serde(skip_serializing_if = "std::ops::Not::not")]
23    pub default: bool,
24}
25
26#[derive(Clone, Debug, Serialize, PartialEq, Eq)]
27pub struct ProviderInfo {
28    pub provider: String,
29    /// Where the list came from (`cli`, `help`, `config`).
30    pub source: String,
31    pub models: Vec<ModelInfo>,
32}
33
34pub const PROVIDERS: &[&str] = &["claude", "codex", "grok", "kimi"];
35
36fn which(bin: &str) -> Option<PathBuf> {
37    let path = std::env::var_os("PATH")?;
38    std::env::split_paths(&path).map(|d| d.join(bin)).find(|p| p.is_file())
39}
40
41/// Run `bin args` with a deadline; stdout as text (stderr dropped, no stdin).
42fn run(bin: &Path, args: &[&str], deadline: Duration) -> Option<String> {
43    let mut child = Command::new(bin).args(args).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).spawn().ok()?;
44    let mut out = child.stdout.take()?;
45    let reader = std::thread::spawn(move || {
46        let mut buf = Vec::new();
47        let _ = out.by_ref().take(4 << 20).read_to_end(&mut buf);
48        buf
49    });
50    let start = Instant::now();
51    loop {
52        match child.try_wait() {
53            Ok(Some(_)) => break,
54            Ok(None) if start.elapsed() < deadline => std::thread::sleep(Duration::from_millis(50)),
55            _ => {
56                let _ = child.kill();
57                let _ = child.wait();
58                return None;
59            }
60        }
61    }
62    String::from_utf8(reader.join().ok()?).ok()
63}
64
65fn ok_id(s: &str) -> bool {
66    !s.is_empty() && s.len() <= 128 && s.bytes().all(|b| b.is_ascii_alphanumeric() || b"-_.[]".contains(&b))
67}
68
69pub fn parse_codex(json: &str) -> Vec<ModelInfo> {
70    let Ok(v) = serde_json::from_str::<serde_json::Value>(json) else { return Vec::new() };
71    let list = v.get("models").and_then(|m| m.as_array()).cloned().unwrap_or_default();
72    list.iter()
73        .filter(|m| m.get("visibility").and_then(|x| x.as_str()).is_none_or(|x| x == "list"))
74        .filter_map(|m| {
75            let id = m.get("slug").or_else(|| m.get("id")).and_then(|x| x.as_str())?;
76            ok_id(id).then(|| ModelInfo {
77                id: id.to_owned(),
78                efforts: m
79                    .get("supported_reasoning_levels")
80                    .and_then(|l| l.as_array())
81                    .map(|l| l.iter().filter_map(|e| e.get("effort").and_then(|x| x.as_str())).filter(|e| ok_id(e)).map(str::to_owned).collect())
82                    .unwrap_or_default(),
83                default: false,
84            })
85        })
86        .collect()
87}
88
89pub fn parse_grok(text: &str) -> Vec<ModelInfo> {
90    text.lines()
91        .filter_map(|l| {
92            let t = l.trim_start();
93            let (default, rest) = if let Some(r) = t.strip_prefix("* ") { (true, r) } else { (false, t.strip_prefix("- ")?) };
94            let id = rest.split_whitespace().next()?;
95            ok_id(id).then(|| ModelInfo { id: id.to_owned(), efforts: Vec::new(), default })
96        })
97        .collect()
98}
99
100/// Quoted aliases in the `--model` paragraph of `claude --help`.
101pub fn parse_claude_help(help: &str) -> Vec<ModelInfo> {
102    let Some(start) = help.find("--model") else { return Vec::new() };
103    let para: String = help[start..].lines().take_while(|l| !l.trim().is_empty()).take(8).enumerate()
104        .filter(|(i, l)| *i == 0 || !l.trim_start().starts_with("--"))
105        .map(|(_, l)| l)
106        .collect::<Vec<_>>()
107        .join(" ");
108    let mut out: Vec<ModelInfo> = Vec::new();
109    for (i, part) in para.split('\'').enumerate() {
110        if i % 2 == 1 && ok_id(part) && !out.iter().any(|m| m.id == part) {
111            out.push(ModelInfo { id: part.to_owned(), efforts: Vec::new(), default: false });
112        }
113    }
114    out
115}
116
117pub fn parse_kimi_config(toml_text: &str) -> Vec<ModelInfo> {
118    let mut out = Vec::new();
119    let mut default = None;
120    for line in toml_text.lines() {
121        let l = line.trim();
122        if let Some(rest) = l.strip_prefix("[models.").and_then(|r| r.strip_suffix(']')) {
123            let id = rest.trim_matches('"');
124            if ok_id(id) {
125                out.push(ModelInfo { id: id.to_owned(), efforts: Vec::new(), default: false });
126            }
127        } else if let Some(v) = l.strip_prefix("default_model") {
128            default = v.trim_start().strip_prefix('=').map(|v| v.trim().trim_matches('"').to_owned());
129        }
130    }
131    for m in &mut out {
132        m.default = default.as_deref() == Some(m.id.as_str());
133    }
134    out
135}
136
137fn home() -> Option<PathBuf> {
138    std::env::var_os("HOME").map(PathBuf::from)
139}
140
141/// Detect one provider; `None` when its CLI is not on PATH.
142pub fn detect(provider: &str) -> Option<ProviderInfo> {
143    let deadline = Duration::from_secs(20);
144    let (bin, source, models) = match provider {
145        "codex" => {
146            let bin = which("codex")?;
147            let m = run(&bin, &["debug", "models"], deadline).map(|s| parse_codex(&s)).unwrap_or_default();
148            (bin, "cli", m)
149        }
150        "grok" => {
151            let bin = which("grok")?;
152            let m = run(&bin, &["models"], deadline).map(|s| parse_grok(&s)).unwrap_or_default();
153            (bin, "cli", m)
154        }
155        "claude" => {
156            let bin = which("claude")?;
157            let mut m = run(&bin, &["--help"], deadline).map(|s| parse_claude_help(&s)).unwrap_or_default();
158            if let Some(set) = home().and_then(|h| std::fs::read(h.join(".claude/settings.json")).ok()).and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok()) {
159                if let Some(id) = set.get("model").and_then(|x| x.as_str()).filter(|s| ok_id(s)) {
160                    match m.iter_mut().find(|x| x.id == id) {
161                        Some(x) => x.default = true,
162                        None => m.push(ModelInfo { id: id.to_owned(), efforts: Vec::new(), default: true }),
163                    }
164                }
165            }
166            (bin, "help", m)
167        }
168        "kimi" => {
169            let bin = which("kimi")?;
170            let m = home().and_then(|h| std::fs::read_to_string(h.join(".kimi/config.toml")).ok()).map(|s| parse_kimi_config(&s)).unwrap_or_default();
171            (bin, "config", m)
172        }
173        _ => return None,
174    };
175    let _ = bin;
176    Some(ProviderInfo { provider: provider.to_owned(), source: source.to_owned(), models })
177}
178
179/// All providers whose CLI this node can run.
180pub fn detect_all() -> Vec<ProviderInfo> {
181    PROVIDERS.iter().filter_map(|p| detect(p)).collect()
182}
183
184#[cfg(test)]
185mod tests {
186    use super::*;
187
188    #[test]
189    fn parses_codex_catalog() {
190        let j = r#"{"models":[{"slug":"m-a","visibility":"list","supported_reasoning_levels":[{"effort":"low"},{"effort":"high"}]},{"slug":"m-hidden","visibility":"hide"},{"slug":"bad slug","visibility":"list"}]}"#;
191        let m = parse_codex(j);
192        assert_eq!(m.len(), 1);
193        assert_eq!(m[0].id, "m-a");
194        assert_eq!(m[0].efforts, ["low", "high"]);
195        assert!(parse_codex("nope").is_empty());
196    }
197
198    #[test]
199    fn parses_grok_list() {
200        let m = parse_grok("You are not authenticated.\n\nDefault model: g-1\n\nAvailable models:\n  * g-1 (default)\n  - g-0\n");
201        assert_eq!(m.iter().map(|x| (x.id.as_str(), x.default)).collect::<Vec<_>>(), [("g-1", true), ("g-0", false)]);
202    }
203
204    #[test]
205    fn parses_claude_help_aliases() {
206        let h = "  --mcp-config <c>    x\n  --model <model>     Model for the current session. Provide\n                      an alias for the latest model (e.g.\n                      'a1', 'b2', or 'c3') or a\n                      model's full name.\n  --name <n>          y 'zz'\n";
207        let m = parse_claude_help(h);
208        assert_eq!(m.iter().map(|x| x.id.as_str()).collect::<Vec<_>>(), ["a1", "b2", "c3"]);
209    }
210
211    #[test]
212    fn parses_kimi_config() {
213        let m = parse_kimi_config("default_model = \"k2\"\n[models.k1]\nprovider = \"x\"\n[models.\"k2\"]\n");
214        assert_eq!(m.iter().map(|x| (x.id.as_str(), x.default)).collect::<Vec<_>>(), [("k1", false), ("k2", true)]);
215    }
216}
hatchery_node/provider_inventory.rs

hatchery_node/
provider_inventory.rs
