//! Every agent the app can run and what it offers, in one catalog the
//! pickers and settings read. Each configured provider instance gets a
//! background health check: Claude's models, account, slash commands and
//! usage limits come from a short-lived `claude` asked over its control
//! channel, Pi's models from asking `pi` for what its providers offer. Also
//! the user's favorite models.
use std::{
io::{BufRead, BufReader, Write},
path::Path,
process::Stdio,
sync::mpsc,
time::{Duration, Instant, SystemTime},
};
use gpui_kit::*;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use crate::claude::{Effort, base_command};
use crate::settings::{self, ProviderInstance};
/// The kind of agent behind a thread.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Provider {
#[default]
Claude,
Pi,
}
impl Provider {
pub const ALL: [Provider; 2] = [Provider::Claude, Provider::Pi];
pub fn label(self) -> &'static str {
match self {
Provider::Claude => "Claude",
Provider::Pi => "Pi",
}
}
pub fn key(self) -> &'static str {
match self {
Provider::Claude => "claude",
Provider::Pi => "pi",
}
}
pub fn from_key(key: &str) -> Option<Self> {
Self::ALL.into_iter().find(|provider| provider.key() == key)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct ModelEntry {
pub provider: Provider,
/// The provider instance offering it (`claude`, `claude-2`, `pi`).
pub instance: String,
/// What the agent is launched with: a Claude alias or model id, or Pi's
/// `provider/model`.
pub id: String,
/// The concrete model, e.g. `claude-opus-5-5` behind the `opus` alias.
pub resolved: String,
pub name: String,
pub detail: String,
/// Older Claude models, listed under "Legacy models".
pub legacy: bool,
/// Reasoning levels the model accepts.
pub efforts: Vec<Effort>,
pub fast_mode: bool,
pub auto_mode: bool,
pub context_window: Option<u64>,
}
impl ModelEntry {
/// The key favorites and defaults are stored under.
pub fn key(&self) -> String {
format!("{}:{}", self.instance, self.id)
}
}
/// A `/` command or skill an agent offers.
#[derive(Clone, Debug, PartialEq)]
pub struct SlashCommand {
pub name: String,
pub description: String,
pub argument_hint: String,
/// Installed skills, as opposed to the agent's own commands.
pub skill: bool,
}
#[derive(Clone, Debug, PartialEq)]
pub enum ProbeStatus {
/// Turned off in the settings.
Disabled,
Checking,
Ready,
/// The binary isn't installed (or isn't on a path we look at).
Missing,
Failed(String),
}
/// What the last health check found out about one provider instance.
#[derive(Clone, Debug)]
pub struct InstanceState {
pub config: ProviderInstance,
pub status: ProbeStatus,
/// A check is running; the fields keep the previous one's findings.
pub checking: bool,
pub models: Vec<ModelEntry>,
/// Claude's `default` entry, which the picker shows as the model it resolves to.
pub default: Option<ModelEntry>,
/// The signed-in account (Claude's email).
pub account: Option<String>,
/// The subscription or login (`Claude Team`).
pub plan: Option<String>,
pub version: Option<String>,
/// The newest published version, once an update check ran.
pub latest: Option<String>,
/// Claude's `get_usage` reply: plan limits and how much of them is used.
pub usage: Option<Value>,
pub commands: Vec<SlashCommand>,
pub checked: Option<SystemTime>,
}
impl InstanceState {
fn new(config: ProviderInstance) -> Self {
Self {
status: if config.enabled { ProbeStatus::Checking } else { ProbeStatus::Disabled },
config,
checking: false,
models: Vec::new(),
default: None,
account: None,
plan: None,
version: None,
latest: None,
usage: None,
commands: Vec::new(),
checked: None,
}
}
pub fn id(&self) -> &str {
&self.config.id
}
pub fn label(&self) -> String {
self.config.label()
}
pub fn kind(&self) -> Provider {
self.config.kind
}
/// Whether a newer version than the installed one is out.
pub fn update_available(&self) -> bool {
match (&self.version, &self.latest) {
(Some(version), Some(latest)) => version_newer(latest, version),
_ => false,
}
}
}
pub struct Catalog {
pub instances: Vec<InstanceState>,
favorites: Vec<String>,
}
impl Global for Catalog {}
/// What one health check of an instance found.
#[derive(Default)]
struct Probe {
models: Vec<ModelEntry>,
default: Option<ModelEntry>,
account: Option<String>,
plan: Option<String>,
version: Option<String>,
usage: Option<Value>,
commands: Vec<SlashCommand>,
}
impl Catalog {
pub fn init(cx: &mut App) {
let saved = settings::load();
cx.set_global(Catalog {
instances: saved.providers.into_iter().map(InstanceState::new).collect(),
favorites: saved.favorites,
});
Self::refresh_all(cx);
}
pub fn global(cx: &App) -> &Catalog {
cx.global::<Catalog>()
}
/// Picks up added, removed and edited instances from the settings, and
/// checks the ones that changed.
pub fn sync_instances(cx: &mut App) {
let configs = settings::instances();
let catalog = cx.global_mut::<Catalog>();
let mut changed = Vec::new();
let mut instances = Vec::new();
for config in configs {
match catalog.instances.iter().position(|state| state.config.id == config.id) {
Some(ix) => {
let mut state = catalog.instances[ix].clone();
if state.config != config {
let enabled = config.enabled;
state.config = config;
if !enabled {
state.status = ProbeStatus::Disabled;
}
changed.push(state.config.id.clone());
}
instances.push(state);
}
None => {
changed.push(config.id.clone());
instances.push(InstanceState::new(config));
}
}
}
catalog.instances = instances;
for id in changed {
Self::refresh(&id, cx);
}
cx.refresh_windows();
}
/// Checks every enabled instance again.
pub fn refresh_all(cx: &mut App) {
let ids: Vec<String> = Self::global(cx).instances.iter().map(|state| state.config.id.clone()).collect();
for id in ids {
Self::refresh(&id, cx);
}
}
/// Checks one instance in the background: its version, account, models,
/// commands and limits.
pub fn refresh(id: &str, cx: &mut App) {
let update_checks = settings::get(|settings| settings.update_checks);
let Some(state) = cx.global_mut::<Catalog>().instances.iter_mut().find(|state| state.config.id == id) else {
return;
};
if !state.config.enabled {
state.status = ProbeStatus::Disabled;
cx.refresh_windows();
return;
}
if state.checking {
return;
}
state.checking = true;
if state.checked.is_none() {
state.status = ProbeStatus::Checking;
}
let config = state.config.clone();
cx.refresh_windows();
let id = id.to_string();
let probe = cx.background_executor().spawn(async move {
let probe = match config.kind {
Provider::Claude => probe_claude(&config),
Provider::Pi => probe_pi(&config),
};
let latest = if update_checks { latest_version(config.kind) } else { None };
(probe, latest)
});
cx.spawn(async move |cx| {
let (result, latest) = probe.await;
cx.update(|cx| {
let Some(state) = cx.global_mut::<Catalog>().instances.iter_mut().find(|state| state.config.id == id)
else {
return;
};
state.checking = false;
state.checked = Some(SystemTime::now());
if latest.is_some() {
state.latest = latest;
}
match result {
Ok(probe) => {
state.status = ProbeStatus::Ready;
if !probe.models.is_empty() || state.config.kind == Provider::Pi {
state.models = probe.models;
state.default = probe.default;
}
state.account = probe.account.or(state.account.take());
state.plan = probe.plan.or(state.plan.take());
state.version = probe.version.or(state.version.take());
if probe.usage.is_some() {
state.usage = probe.usage;
}
if !probe.commands.is_empty() {
state.commands = probe.commands;
}
}
Err(status) => {
if state.config.enabled {
state.status = status;
}
if state.config.kind == Provider::Pi {
state.models.clear();
}
}
}
cx.refresh_windows();
})
})
.detach();
}
pub fn instance(&self, id: &str) -> Option<&InstanceState> {
self.instances.iter().find(|state| state.config.id == id)
}
/// The enabled instances, in the order the settings list them.
pub fn enabled(&self) -> impl Iterator<Item = &InstanceState> {
self.instances.iter().filter(|state| state.config.enabled)
}
pub fn label(&self, id: &str) -> String {
self.instance(id).map(InstanceState::label).unwrap_or_else(|| id.to_string())
}
/// The first enabled instance of a kind.
pub fn first_of(&self, kind: Provider) -> Option<&InstanceState> {
self.enabled().find(|state| state.config.kind == kind)
}
/// Takes Claude's model list, account and commands from a session's
/// `initialize` reply.
pub fn set_claude_info(instance: &str, info: &Value, cx: &mut App) {
let probe = claude_probe_from(instance, info);
let Some(state) = cx.global_mut::<Catalog>().instances.iter_mut().find(|state| state.config.id == instance)
else {
return;
};
let mut changed = false;
if probe.account.is_some() && state.account != probe.account {
state.account = probe.account;
state.plan = probe.plan;
changed = true;
}
if !probe.models.is_empty() && state.models != probe.models {
state.models = probe.models;
state.default = probe.default;
changed = true;
}
if !probe.commands.is_empty() && state.commands != probe.commands {
state.commands = probe.commands;
changed = true;
}
if state.status != ProbeStatus::Ready {
state.status = ProbeStatus::Ready;
changed = true;
}
if changed {
cx.refresh_windows();
}
}
pub fn models(&self, instance: &str) -> &[ModelEntry] {
self.instance(instance).map(|state| state.models.as_slice()).unwrap_or_default()
}
/// Every enabled instance's models.
pub fn all_models(&self) -> impl Iterator<Item = &ModelEntry> {
self.enabled().flat_map(|state| &state.models)
}
/// The entry for a thread's model; `None` means the provider's default.
pub fn find(&self, instance: &str, id: Option<&str>) -> Option<&ModelEntry> {
let state = self.instance(instance)?;
match id {
None => state.default.as_ref(),
Some(id) => state.models.iter().find(|model| model.id == id),
}
}
/// The entry stored under `key` (see [`ModelEntry::key`]).
pub fn find_key(&self, key: &str) -> Option<&ModelEntry> {
self.instances.iter().flat_map(|state| &state.models).find(|model| model.key() == key)
}
pub fn commands(&self, instance: &str) -> &[SlashCommand] {
self.instance(instance).map(|state| state.commands.as_slice()).unwrap_or_default()
}
pub fn is_favorite(&self, model: &ModelEntry) -> bool {
self.favorites.contains(&model.key())
}
pub fn favorites(&self) -> Vec<&ModelEntry> {
self.favorites.iter().filter_map(|key| self.all_models().find(|model| &model.key() == key)).collect()
}
pub fn toggle_favorite(model: &ModelEntry, cx: &mut App) {
let key = model.key();
let catalog = cx.global_mut::<Catalog>();
match catalog.favorites.iter().position(|favorite| *favorite == key) {
Some(ix) => {
catalog.favorites.remove(ix);
}
None => catalog.favorites.push(key),
}
let favorites = catalog.favorites.clone();
settings::update(|settings| settings.favorites = favorites);
cx.refresh_windows();
}
}
/// Splits a model key into its instance and model id. Keys from before
/// instances existed name the kind, which is also its first instance's id.
pub fn split_key(key: &str) -> Option<(&str, &str)> {
key.split_once(':')
}
/// Parses Claude's `initialize` reply: the models (the default entry apart),
/// the account and the commands.
fn claude_probe_from(instance: &str, info: &Value) -> Probe {
let mut default = None;
let mut models = Vec::new();
for model in info.get("models").and_then(Value::as_array).into_iter().flatten() {
let Some(id) = model.get("value").and_then(Value::as_str) else { continue };
let text = |key: &str| model.get(key).and_then(Value::as_str).unwrap_or_default().to_string();
let flag = |key: &str| model.get(key).and_then(Value::as_bool).unwrap_or(false);
let display = text("displayName");
let entry = ModelEntry {
provider: Provider::Claude,
instance: instance.to_string(),
id: id.to_string(),
resolved: Some(text("resolvedModel")).filter(|model| !model.is_empty()).unwrap_or_else(|| id.into()),
name: if display.starts_with("Claude") { display.clone() } else { format!("Claude {display}") },
detail: text("description"),
// Aliases (`opus`, `sonnet`) track the current models; full ids are older ones.
legacy: id.starts_with("claude-"),
efforts: model
.get("supportedEffortLevels")
.and_then(Value::as_array)
.map(|levels| levels.iter().filter_map(Value::as_str).filter_map(Effort::from_cli).collect())
.unwrap_or_default(),
fast_mode: flag("supportsFastMode"),
auto_mode: flag("supportsAutoMode"),
context_window: None,
};
if id == "default" {
default = Some(entry);
} else {
models.push(entry);
}
}
// Present the default as the model it resolves to.
if let Some(default) = default.as_mut()
&& let Some(current) = models.iter().find(|model| !model.legacy && model.resolved == default.resolved)
{
default.name = current.name.clone();
}
let commands = info
.get("commands")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|command| {
let name = command.get("name")?.as_str()?;
// Internal commands start with underscores.
(!name.starts_with('_')).then(|| SlashCommand {
name: name.to_string(),
description: command.get("description").and_then(Value::as_str).unwrap_or_default().to_string(),
argument_hint: command.get("argumentHint").and_then(Value::as_str).unwrap_or_default().to_string(),
// Claude's own commands are marked builtin; skills from
// plugins and skill folders aren't.
skill: command.get("builtin").and_then(Value::as_bool) != Some(true),
})
})
.collect();
Probe {
models,
default,
account: info.pointer("/account/email").and_then(Value::as_str).map(str::to_string),
plan: info
.pointer("/account/subscriptionType")
.and_then(Value::as_str)
.map(|plan| if plan.to_lowercase().contains("subscription") { plan.to_string() } else { format!("{plan} Subscription") }),
version: info.get("claude_code_version").and_then(Value::as_str).map(str::to_string),
usage: None,
commands,
}
}
/// Starts `claude` just long enough to ask what it offers and how much of
/// the plan's limits is used. Nothing is sent to a model.
fn probe_claude(config: &ProviderInstance) -> Result<Probe, ProbeStatus> {
let failed = |err: &dyn std::fmt::Display| ProbeStatus::Failed(err.to_string());
let (_, mut command) = base_command(config).map_err(|_| ProbeStatus::Missing)?;
command
.args(["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"])
.arg("--no-session-persistence")
.current_dir(std::env::temp_dir())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = command.spawn().map_err(|err| failed(&err))?;
let mut stdin = child.stdin.take().ok_or_else(|| failed(&"no stdin"))?;
let stdout = child.stdout.take().ok_or_else(|| failed(&"no stdout"))?;
let stderr = child.stderr.take().ok_or_else(|| failed(&"no stderr"))?;
let request = |id: &str, subtype: &str| {
json!({"type": "control_request", "request_id": id, "request": {"subtype": subtype}}).to_string()
};
writeln!(stdin, "{}", request("probe-init", "initialize")).map_err(|err| failed(&err))?;
writeln!(stdin, "{}", request("probe-usage", "get_usage")).map_err(|err| failed(&err))?;
let (tx, rx) = mpsc::channel();
std::thread::spawn(move || {
for line in BufReader::new(stdout).lines().map_while(Result::ok) {
if let Ok(value) = serde_json::from_str::<Value>(&line)
&& value.get("type").and_then(Value::as_str) == Some("control_response")
&& tx.send(value["response"].clone()).is_err()
{
return;
}
}
});
let stderr_tail = std::thread::spawn(move || {
BufReader::new(stderr).lines().map_while(Result::ok).filter(|line| !line.trim().is_empty()).last()
});
let deadline = Instant::now() + Duration::from_secs(25);
let (mut init, mut usage) = (None, None);
while init.is_none() || usage.is_none() {
let Some(left) = deadline.checked_duration_since(Instant::now()) else { break };
let Ok(response) = rx.recv_timeout(left) else { break };
let ok = response.get("subtype").and_then(Value::as_str) == Some("success");
match response.get("request_id").and_then(Value::as_str) {
Some("probe-init") => init = Some(ok.then(|| response["response"].clone())),
Some("probe-usage") => usage = Some(ok.then(|| response["response"].clone())),
_ => {}
}
}
drop(stdin);
let _ = child.kill();
let _ = child.wait();
let Some(Some(info)) = init else {
let detail = stderr_tail.join().ok().flatten().unwrap_or_else(|| "Claude Code didn't answer".into());
return Err(failed(&detail));
};
let mut probe = claude_probe_from(&config.id, &info);
probe.usage = usage.flatten().filter(|usage| usage.get("rate_limits_available").and_then(Value::as_bool) != Some(false));
Ok(probe)
}
/// Starts `pi` just long enough to list the models its providers offer, and
/// asks its version.
fn probe_pi(config: &ProviderInstance) -> Result<Probe, ProbeStatus> {
let failed = |err: &dyn std::fmt::Display| ProbeStatus::Failed(err.to_string());
let (_, mut command) = base_command(config).map_err(|_| ProbeStatus::Missing)?;
command
.args(["--mode", "rpc", "--no-session"])
.current_dir(std::env::temp_dir())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::null());
let mut child = command.spawn().map_err(|err| failed(&err))?;
let mut stdin = child.stdin.take().ok_or_else(|| failed(&"no stdin"))?;
let stdout = child.stdout.take().ok_or_else(|| failed(&"no stdout"))?;
let request = json!({"id": "models", "type": "get_available_models"});
writeln!(stdin, "{request}").map_err(|err| failed(&err))?;
let (tx, rx) = mpsc::channel();
std::thread::spawn(move || {
for line in BufReader::new(stdout).lines().map_while(Result::ok) {
if let Ok(value) = serde_json::from_str::<Value>(&line)
&& value.get("id").and_then(Value::as_str) == Some("models")
{
let _ = tx.send(value);
return;
}
}
});
let reply = rx.recv_timeout(Duration::from_secs(30));
drop(stdin);
let _ = child.kill();
let _ = child.wait();
let reply = reply.map_err(|_| failed(&"pi didn't list its models"))?;
if reply.get("success").and_then(Value::as_bool) != Some(true) {
let error = reply.get("error").and_then(Value::as_str).unwrap_or("unknown error");
return Err(failed(&error));
}
let models = reply
.pointer("/data/models")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|model| pi_model_from(&config.id, model))
.collect();
let version = base_command(config).ok().and_then(|(_, mut command)| {
let output = command.arg("--version").stdin(Stdio::null()).stderr(Stdio::null()).output().ok()?;
first_version(&String::from_utf8_lossy(&output.stdout))
});
Ok(Probe { models, account: None, plan: None, version, ..Probe::default() })
}
pub fn pi_model_from(instance: &str, model: &Value) -> Option<ModelEntry> {
let id = model.get("id")?.as_str()?;
let provider = model.get("provider")?.as_str()?;
let reasoning = model.get("reasoning").and_then(Value::as_bool).unwrap_or(false);
Some(ModelEntry {
provider: Provider::Pi,
instance: instance.to_string(),
id: format!("{provider}/{id}"),
resolved: id.to_string(),
name: model.get("name").and_then(Value::as_str).unwrap_or(id).to_string(),
detail: provider_label(provider),
legacy: false,
efforts: if reasoning {
vec![Effort::Off, Effort::Minimal, Effort::Low, Effort::Medium, Effort::High]
} else {
vec![Effort::Off]
},
fast_mode: false,
auto_mode: false,
context_window: model.get("contextWindow").and_then(Value::as_u64),
})
}
/// The newest published version of an agent, from the npm registry.
fn latest_version(kind: Provider) -> Option<String> {
let package = match kind {
Provider::Claude => "@anthropic-ai/claude-code",
Provider::Pi => "@earendil-works/pi-coding-agent",
};
let body = crate::http::get(&format!("https://registry.npmjs.org/{package}/latest"), &[], Duration::from_secs(10)).ok()?;
serde_json::from_str::<Value>(&body).ok()?.get("version")?.as_str().map(str::to_string)
}
/// The command that updates an agent in place, and how to describe it.
pub fn update_command(config: &ProviderInstance) -> Option<(std::process::Command, &'static str)> {
let (binary, mut command) = base_command(config).ok()?;
match config.kind {
Provider::Claude => {
command.arg("update");
Some((command, "claude update"))
}
Provider::Pi => {
// Pi is an npm package; update it with the npm next to it.
let npm = binary.parent().map(|dir| dir.join("npm")).filter(|npm| npm.exists());
let mut command = std::process::Command::new(npm.as_deref().unwrap_or(Path::new("npm")));
command.args(["install", "-g", "@earendil-works/pi-coding-agent@latest"]);
Some((command, "npm install -g @earendil-works/pi-coding-agent"))
}
}
}
/// The first `1.2.3`-looking word in `text`.
fn first_version(text: &str) -> Option<String> {
text.split_whitespace()
.map(|word| word.trim_start_matches('v'))
.find(|word| word.split('.').count() >= 2 && word.split('.').all(|part| part.parse::<u64>().is_ok()))
.map(str::to_string)
}
/// Whether version `a` is newer than `b`, comparing numerically.
fn version_newer(a: &str, b: &str) -> bool {
let parse = |version: &str| -> Vec<u64> {
version.trim_start_matches('v').split(['.', '-', '+']).map_while(|part| part.parse().ok()).collect()
};
parse(a) > parse(b)
}
/// `openai-codex` → `OpenAI Codex`.
fn provider_label(provider: &str) -> String {
provider
.split(['-', '_'])
.map(|word| match word {
"openai" => "OpenAI".to_string(),
"openrouter" => "OpenRouter".to_string(),
"xai" => "xAI".to_string(),
"ai" => "AI".to_string(),
word => {
let mut chars = word.chars();
chars.next().map(|first| first.to_uppercase().chain(chars).collect()).unwrap_or_default()
}
})
.collect::<Vec<_>>()
.join(" ")
}
#[cfg(test)]
mod tests {
use super::{claude_probe_from, first_version, provider_label, version_newer};
use serde_json::json;
#[::core::prelude::v1::test]
fn provider_labels() {
assert_eq!(provider_label("openai-codex"), "OpenAI Codex");
assert_eq!(provider_label("anthropic"), "Anthropic");
assert_eq!(provider_label("openrouter"), "OpenRouter");
assert_eq!(provider_label("google_vertex"), "Google Vertex");
}
#[::core::prelude::v1::test]
fn claude_default_takes_the_current_name() {
let info = json!({
"models": [
{"value": "default", "resolvedModel": "claude-opus-5-5", "displayName": "Default (recommended)"},
{"value": "opus", "resolvedModel": "claude-opus-5-5", "displayName": "Opus 5.5",
"supportedEffortLevels": ["low", "high"], "supportsFastMode": true},
{"value": "claude-haiku-4-5", "displayName": "Haiku 4.5"},
],
"account": {"email": "me@example.com", "subscriptionType": "Claude Team"},
"commands": [
{"name": "compact", "description": "Compact", "argumentHint": "", "builtin": true},
{"name": "pdf", "description": "PDF skill", "argumentHint": ""},
{"name": "__internal", "description": "", "argumentHint": "", "builtin": true},
],
"claude_code_version": "2.1.296",
});
let probe = claude_probe_from("claude", &info);
assert_eq!(probe.default.unwrap().name, "Claude Opus 5.5");
assert_eq!(probe.models.len(), 2);
assert!(probe.models[1].legacy);
assert_eq!(probe.models[0].efforts.len(), 2);
assert_eq!(probe.models[0].key(), "claude:opus");
assert_eq!(probe.plan.as_deref(), Some("Claude Team Subscription"));
assert_eq!(probe.commands.len(), 2);
assert!(!probe.commands[0].skill && probe.commands[1].skill);
assert_eq!(probe.version.as_deref(), Some("2.1.296"));
}
#[::core::prelude::v1::test]
fn compares_versions() {
assert!(version_newer("2.1.300", "2.1.296"));
assert!(!version_newer("2.1.296", "2.1.296"));
assert!(version_newer("1.10.0", "1.9.9"));
assert_eq!(first_version("pi v1.1.0\n").as_deref(), Some("1.1.0"));
assert_eq!(first_version("2.1.296 (Claude Code)").as_deref(), Some("2.1.296"));
}
}