use std::path::{Path, PathBuf};
use std::process::Command;
use anyhow::Context;
use clap::Args;
use crate::chat_template::{ThinkingControls, EFFORT_LEVELS};
use crate::daemon;
use crate::providers;
mod agy;
mod aider;
mod claude;
mod cline;
mod codex;
mod common;
mod copilot;
mod docker_agent;
mod droid;
mod dsh;
mod gemini;
mod goose;
mod goose_desktop;
mod grok;
mod hdrm;
mod hermes;
mod kimi;
mod omp;
mod openclaw;
mod opencode;
mod optimizer;
mod pi;
mod qwen;
mod sandbox;
mod vibe;
pub use optimizer::Optimizer;
pub use sandbox::Sandbox;
#[derive(Args, Debug, Clone)]
pub struct LaunchArgs {
#[arg(value_name = "INTEGRATION")]
pub integration: Option<String>,
#[arg(long, short, value_name = "MODEL")]
pub model: Option<String>,
#[arg(long, short = 'p', value_name = "PROVIDER")]
pub provider: Option<String>,
#[arg(long, value_name = "PROVIDER")]
pub overflow_provider: Option<String>,
#[arg(long, value_name = "MODEL")]
pub overflow_model: Option<String>,
#[arg(
long,
value_enum,
value_name = "SANDBOX",
num_args = 0..=1,
default_missing_value = "sbx"
)]
pub sandbox: Option<Sandbox>,
#[arg(long, value_name = "VARIANT", value_parser = super::run::variant_parser())]
pub variant: Option<String>,
#[arg(long, value_enum, value_name = "OPTIMIZER", default_value = "none")]
pub optimizer: Optimizer,
#[arg(last = true, value_name = "ARGS")]
pub extra_args: Vec<String>,
}
pub fn run(args: &LaunchArgs) -> anyhow::Result<()> {
let configured;
let args = match args.integration.as_deref() {
Some(name) => {
let (with_defaults, applied) =
apply_defaults(args, name, || crate::config::launch_defaults(name))?;
if !applied.is_empty() {
eprintln!(
"[llmman] {name}: llmman.conf supplies {}",
applied.join(" ")
);
}
configured = with_defaults;
&configured
}
None => args,
};
let provider = providers::provider_flag(args.provider.as_deref())?;
let overflow = crate::hybrid::overflow_flags(
args.overflow_provider.as_deref(),
args.overflow_model.as_deref(),
provider,
)?;
let Some(ref name) = args.integration else {
print_integrations();
return Ok(());
};
let variant = args.variant.as_deref();
if let Some(variant) = variant {
anyhow::ensure!(
args.sandbox != Some(Sandbox::Sbx),
"--variant does not work with --sandbox sbx"
);
anyhow::ensure!(
!has_forwarded_model_flag(name, &args.extra_args),
"--variant needs the model as llmman's --model, not after --"
);
spell_variant(name, variant)?;
}
if let Some(id) = canonical_integration(name) {
args.optimizer
.check(id, args.sandbox.is_some(), &args.extra_args)?;
}
if args.sandbox == Some(Sandbox::Sbx) {
return sandbox::run_sbx(
name,
args.model.as_deref(),
provider,
overflow,
&args.extra_args,
);
}
let speech = std::env::var(goose_desktop::TRANSCRIPTION_MODEL_ENV).ok();
check_model_flag(
name,
args.model.as_deref(),
provider,
speech.as_deref(),
&args.extra_args,
)?;
if name.eq_ignore_ascii_case("copilot")
|| name.eq_ignore_ascii_case("copilot-cli")
|| name.eq_ignore_ascii_case("droid")
{
common::check_daemon_key_transport(name)?;
}
anyhow::ensure!(
overflow.is_none() || args.model.as_deref().is_some_and(|m| !m.trim().is_empty()),
"--overflow-model needs --model naming the local model to pair it with"
);
if let Some(kind) = args.sandbox {
let id = name.to_lowercase();
let carries_key =
provider.is_some() || overflow.is_some() || crate::auth::client_key().is_some();
let configured_by_file =
CONFIGURED_BY_FILE.contains(&id.as_str()) || (id == "opencode" && variant.is_some());
sandbox::prepare(
kind,
&id,
sandbox_state(&id)?,
configured_by_file,
carries_key,
)?;
}
if name.eq_ignore_ascii_case("cline") {
cline::ensure_cline_installed()?;
}
if name.eq_ignore_ascii_case("docker-agent") {
docker_agent::check_docker_agent_args(&args.extra_args)?;
}
if name.eq_ignore_ascii_case("kimi") && provider.is_none() && overflow.is_none() {
kimi::check_kimi_args(args.model.as_deref(), &args.extra_args)?;
}
check_installed(name)?;
let mut thinking = None;
let mut vision = false;
let mut context_length = None;
let context_window: Option<u64>;
let mut max_output = None;
let (model, api_key) = match provider {
Some(provider) => {
check_provider_supported(name)?;
crate::daemon::ensure_server("")?;
let per_request = !PROVIDER_NEEDS_DAEMON_KEY.contains(&name.to_lowercase().as_str());
let hosted =
resolve_provider_model(provider, args.model.as_deref(), name, per_request)?;
thinking = hosted.thinking.map(Thinking::Listed);
context_window = hosted.context_window;
max_output = hosted.max_output;
(hosted.reference, hosted.api_key)
}
None => {
let model = args
.model
.as_deref()
.map(crate::shortnames::resolve_ollama_api)
.transpose()?
.unwrap_or_default();
crate::daemon::ensure_server(&model)?;
if !model.is_empty() {
let info = crate::daemon::ensure_model_pulled(&model)?;
thinking = info.thinking_controls().map(Thinking::Template);
vision = info.vision();
context_length = info.context_length();
}
let local_window = (declares_context_window(name)
&& !model.is_empty()
&& (!name.eq_ignore_ascii_case("claude")
|| claude::runs_model(&model, &args.extra_args)))
.then(|| local_context_window(&model, context_length))
.flatten();
match overflow {
Some((provider, hosted)) => {
check_provider_supported(name)?;
let per_request =
!PROVIDER_NEEDS_DAEMON_KEY.contains(&name.to_lowercase().as_str());
let remote = resolve_provider_model(provider, Some(hosted), name, per_request)?;
context_window = pair_context_window(local_window, remote.context_window);
max_output = remote.max_output;
(
crate::hybrid::pair_with_local(&model, &remote.reference)?,
remote.api_key,
)
}
None => {
context_window = local_window;
(model, integration_key())
}
}
}
};
let launched = launch(
name,
&model,
&api_key,
thinking.as_ref(),
variant,
vision,
context_window,
max_output,
&args.extra_args,
args.optimizer,
);
hdrm::stop();
launched
}
fn apply_defaults(
args: &LaunchArgs,
name: &str,
load: impl FnOnce() -> Result<crate::config::LaunchConf, &'static str>,
) -> anyhow::Result<(LaunchArgs, Vec<String>)> {
let mut effective = args.clone();
let mut applied = Vec::new();
if args.provider.is_some()
|| args.model.is_some()
|| args.overflow_provider.is_some()
|| args.overflow_model.is_some()
{
return Ok((effective, applied));
}
let mut defaults = load().map_err(|e| anyhow::anyhow!("cannot read launch defaults: {e}"))?;
if has_forwarded_model_flag(name, &args.extra_args) {
defaults.variant = None;
}
for (slot, configured, flag) in [
(&mut effective.provider, defaults.provider, "--provider"),
(&mut effective.model, defaults.model, "--model"),
(&mut effective.variant, defaults.variant, "--variant"),
] {
if let (None, Some(value)) = (&*slot, configured) {
applied.push(format!("{flag} {value}"));
*slot = Some(value);
}
}
Ok((effective, applied))
}
fn integration_key() -> String {
crate::auth::client_key().unwrap_or_else(|| providers::PLACEHOLDER_API_KEY.to_string())
}
const MODEL_REQUIRED: &[&str] = &[
"qwen",
"dsh",
"agy",
"goose",
"goose-desktop",
"grok",
"cline",
"pi",
"omp",
"copilot",
"copilot-cli",
"droid",
"docker-agent",
];
const MODEL_FLAG_FORWARDED: &[&str] = &[
"claude",
"qwen",
"goose",
"grok",
"cline",
"omp",
"copilot",
"copilot-cli",
"droid",
];
fn check_model_flag(
integration: &str,
model: Option<&str>,
provider: Option<&str>,
speech_model: Option<&str>,
extra_args: &[String],
) -> anyhow::Result<()> {
let name = integration.to_lowercase();
let model = model.map(str::trim).filter(|m| !m.is_empty());
let Some(model) = model else {
if MODEL_REQUIRED.contains(&name.as_str()) {
let dictation = name == "goose-desktop" && provider.is_none();
if dictation && speech_model.is_some_and(|s| !s.trim().is_empty()) {
return Ok(());
}
let with_provider = provider.map_or(String::new(), |p| format!(" --provider {p}"));
let or_dictate = if dictation {
format!(
", or set {}=<speech model> for dictation only",
goose_desktop::TRANSCRIPTION_MODEL_ENV
)
} else {
String::new()
};
anyhow::bail!(
"{name} needs a model: llmman launch {name}{with_provider} --model <model>{or_dictate}"
);
}
return Ok(());
};
if has_forwarded_model_flag(&name, extra_args) {
eprintln!(
"[llmman] {name}: the --model after -- wins over --model {model}, the one llmman resolved"
);
}
Ok(())
}
fn has_forwarded_model_flag(integration: &str, extra_args: &[String]) -> bool {
let name = integration.to_lowercase();
let short = (!matches!(name.as_str(), "copilot" | "copilot-cli" | "claude")).then_some("-m");
MODEL_FLAG_FORWARDED.contains(&name.as_str())
&& has_flag(before_terminator(extra_args), "--model", short)
}
fn before_terminator(extra_args: &[String]) -> &[String] {
let end = extra_args
.iter()
.position(|arg| arg == "--")
.unwrap_or(extra_args.len());
&extra_args[..end]
}
fn has_flag(extra_args: &[String], long: &str, short: Option<&str>) -> bool {
extra_args.iter().any(|a| {
a == long
|| a.starts_with(&format!("{long}="))
|| short.is_some_and(|s| a == s || a.starts_with(&format!("{s}=")))
})
}
const PROVIDER_UNSUPPORTED: &[(&str, &str)] = &[
(
"kimi",
"llmman has not verified it with a provider-routed model",
),
(
"gemini",
"llmman cannot confirm it would send the key here rather than to Google",
),
(
"openclaw",
"it only takes a model during first-run onboarding",
),
(
"grok",
"its model catalog cannot represent llmman's provider or hybrid routing reference",
),
(
"omp",
"its Ollama catalog cannot represent llmman's provider or hybrid routing reference",
),
];
const PROVIDER_NEEDS_DAEMON_KEY: &[&str] = &["hermes", "cline", "pi"];
fn declares_context_window(integration: &str) -> bool {
matches!(
integration.to_lowercase().as_str(),
"claude" | "opencode" | "codex" | "pi" | "omp" | "kimi" | "openclaw" | "vibe"
)
}
fn check_provider_supported(integration: &str) -> anyhow::Result<()> {
let name = integration.to_lowercase();
if let Some((_, why)) = PROVIDER_UNSUPPORTED.iter().find(|(id, _)| *id == name) {
anyhow::bail!(
"--provider does not work with {name}: {why}\n\
Run it against a locally served model, or use another integration."
);
}
if !crate::daemon::connects_securely() {
anyhow::bail!(
"--provider needs a local llmman serve, or one over TLS: LLMMAN_HOST points at {}, \
and the provider key would cross the network in cleartext.\n\
Export the key where that daemon runs instead.",
crate::daemon::server()
);
}
if PROVIDER_NEEDS_DAEMON_KEY.contains(&name.as_str())
&& !crate::daemon::reachable_only_locally()
&& crate::auth::client_key().is_none()
{
anyhow::bail!(
"--provider does not work with {name} while llmman serve is bound to {}: \
{name} is configured through a file, so it cannot send the key per request, \
and a daemon reachable from the network will not spend its own.\n\
Bind llmman serve to loopback, or use an integration that carries the key.",
crate::daemon::bind_addr()
);
}
Ok(())
}
struct ResolvedProvider {
reference: String,
api_key: String,
thinking: Option<Vec<String>>,
context_window: Option<u64>,
max_output: Option<u32>,
}
fn resolve_provider_model(
provider: &str,
model: Option<&str>,
integration: &str,
key_travels_per_request: bool,
) -> anyhow::Result<ResolvedProvider> {
let model = model.map(str::trim).filter(|m| !m.is_empty());
let entry = daemon::provider(provider, model)?;
let model = model.ok_or_else(|| {
anyhow::anyhow!(
"--provider {provider} also needs --model\n\n{}",
providers::example_models(&entry.name, &entry.model_ids())
)
})?;
entry.warn_unlisted(model);
let daemon_authenticates = crate::auth::client_key().is_some();
let key = if key_travels_per_request && !daemon_authenticates {
entry.client_key()
} else {
None
};
let key = match (key, key_travels_per_request) {
(Some(key), true) => key,
(_, false) => {
anyhow::ensure!(
entry.key_usable || entry.key_optional,
"{integration} is configured through a file, so it cannot send an API key: \
llmman serve needs a key of its own, and must be bound to loopback (or \
require an API key) to spend it.\n\
Where the daemon runs, {}, then restart it.",
entry.key_hint()
);
integration_key()
}
(None, true) if entry.daemon_key_usable() => {
if !daemon_authenticates {
eprintln!(
"[llmman] warning: no API key for {} here; using the key llmman serve has",
entry.name
);
}
integration_key()
}
(None, true) if entry.key_optional => integration_key(),
(None, true) if daemon_authenticates => anyhow::bail!(
"llmman serve requires an API key, so {integration} sends that one and cannot \
also carry a key for {}: llmman serve needs a key of its own.\n\
Where the daemon runs, {}, then restart it.",
entry.name,
entry.key_hint()
),
(None, true) => anyhow::bail!("no API key for {} — {}", entry.name, entry.key_hint()),
};
Ok(ResolvedProvider {
reference: providers::format_remote_ref(provider, model),
api_key: key,
thinking: entry.thinking_levels(model),
context_window: entry.context_window(model),
max_output: entry.max_output(model),
})
}
struct Integration {
name: &'static str,
description: &'static str,
binary: &'static str,
}
const INTEGRATIONS: &[Integration] = &[
Integration {
name: "claude",
description: "Claude Code",
binary: "claude",
},
Integration {
name: "opencode",
description: "OpenCode",
binary: "opencode",
},
Integration {
name: "codex",
description: "OpenAI Codex CLI",
binary: "codex",
},
Integration {
name: "pi",
description: "Pi coding agent",
binary: "pi",
},
Integration {
name: "omp",
description: "OMP coding agent",
binary: "omp",
},
Integration {
name: "cline",
description: "Cline",
binary: "cline",
},
Integration {
name: "aider",
description: "Aider AI pair programmer",
binary: "aider",
},
Integration {
name: "copilot",
description: "GitHub Copilot CLI",
binary: "copilot",
},
Integration {
name: "droid",
description: "Factory Droid CLI",
binary: "droid",
},
Integration {
name: "kimi",
description: "Kimi Code CLI",
binary: "kimi",
},
Integration {
name: "gemini",
description: "Gemini CLI",
binary: "gemini",
},
Integration {
name: "agy",
description: "Google Antigravity CLI",
binary: "agy",
},
Integration {
name: "hermes",
description: "Hermes Agent",
binary: "hermes",
},
Integration {
name: "openclaw",
description: "OpenClaw",
binary: "openclaw",
},
Integration {
name: "qwen",
description: "Qwen Code",
binary: "qwen",
},
Integration {
name: "dsh",
description: "DeepSeek Harness",
binary: "dsh",
},
Integration {
name: "goose",
description: "Block goose",
binary: "goose",
},
Integration {
name: "goose-desktop",
description: "Block goose Desktop",
binary: "goose-desktop",
},
Integration {
name: "grok",
description: "Grok Build",
binary: "grok",
},
Integration {
name: "docker-agent",
description: "Docker Agent",
binary: "docker-agent",
},
Integration {
name: "vibe",
description: "Mistral Vibe CLI",
binary: "vibe",
},
];
pub(crate) fn canonical_integration(name: &str) -> Option<&'static str> {
integration(name).map(|i| i.name)
}
fn integration(name: &str) -> Option<&'static Integration> {
let name = name.to_ascii_lowercase();
let canonical = match name.as_str() {
"copilot-cli" => "copilot",
other => other,
};
INTEGRATIONS.iter().find(|i| i.name == canonical)
}
fn print_integrations() {
println!("Available integrations:\n");
for i in INTEGRATIONS {
let how = match find_integration_binary(i) {
Some(bin) if bin.file_stem().is_some_and(|s| s == "npx") => " (via npx)",
Some(_) => "",
None => " (not installed)",
};
println!(" {:<14} {}{}", i.name, i.description, how);
}
println!(
"\nUsage: llmman launch <integration> [--model <model>] [--provider <provider>] [--sandbox [sandbox]]"
);
println!(" llmman providers (the providers --provider accepts)");
}
const WINDOWS_PATH_EXTS: &[&str] = &["exe", "cmd", "bat"];
fn find_on_path(binary: &str) -> Option<PathBuf> {
find_on_path_unless(binary, |_| false)
}
fn find_on_path_unless(binary: &str, reject: impl Fn(&Path) -> bool) -> Option<PathBuf> {
if sandbox::runs_from_image() {
return Some(PathBuf::from(binary));
}
let path_var = std::env::var_os("PATH")?;
for dir in std::env::split_paths(&path_var) {
if cfg!(windows) {
for ext in WINDOWS_PATH_EXTS {
let candidate = dir.join(format!("{binary}.{ext}"));
if candidate.is_file() && !reject(&candidate) {
return Some(candidate);
}
}
} else {
let candidate = dir.join(binary);
if candidate.is_file() && !reject(&candidate) {
return Some(candidate);
}
}
}
None
}
fn env_dir(key: &str) -> Option<PathBuf> {
crate::env_dir_from(|var| std::env::var_os(var), key)
}
#[cfg(test)]
fn test_temp_dir(tag: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!(
"llmman-{tag}-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::create_dir_all(&dir).unwrap();
dir
}
fn find_integration_binary(i: &Integration) -> Option<PathBuf> {
match i.name {
"copilot" => copilot::find_copilot(),
"droid" => droid::find_droid(),
"opencode" => opencode::find_opencode(),
"omp" => omp::find_omp(),
"qwen" => qwen::find_qwen(),
"dsh" => dsh::find_dsh().map(|(bin, _)| bin),
"goose" => goose::find_goose(),
"goose-desktop" => goose_desktop::find_goose_desktop(),
"grok" => grok::find_grok(),
"docker-agent" => docker_agent::find_docker_agent(),
_ => find_on_path(i.binary),
}
}
fn check_installed(name: &str) -> anyhow::Result<()> {
let Some(i) = integration(name) else {
return Ok(());
};
if i.name == "cline" || find_integration_binary(i).is_some() {
return Ok(());
}
match i.name {
"dsh" => anyhow::bail!("{}", dsh::DSH_MISSING),
"docker-agent" => Err(docker_agent::docker_agent_missing()),
"goose-desktop" => Err(goose_desktop::goose_desktop_missing()),
_ => anyhow::bail!("{} is not installed", i.binary),
}
}
fn accepts_prompt(answer: &str) -> bool {
matches!(answer.trim().to_ascii_lowercase().as_str(), "y" | "yes")
}
const VARIANT_UNSUPPORTED: &[(&str, &str)] = &[
("kimi", "llmman does not set its thinking yet"),
("openclaw", "it only takes settings at onboarding"),
(
"droid",
"Droid does not support reasoning effort for custom models",
),
("gemini", "llmman's Gemini API ignores thinkingConfig"),
("agy", "llmman's Gemini API ignores thinkingConfig"),
("goose", "it sends effort only for OpenAI's models"),
("goose-desktop", "it sends effort only for OpenAI's models"),
("docker-agent", "it ignores thinking_budget here"),
("vibe", "llmman does not set its thinking yet"),
];
const LOW_TO_MAX: &[&str] = &["low", "medium", "high", "xhigh", "max"];
const VARIANT_SPELLINGS: &[(&str, Option<&str>, &[&str])] = &[
("claude", None, LOW_TO_MAX),
("codex", Some("none"), EFFORT_LEVELS),
("pi", Some("off"), &["minimal", "low", "medium", "high"]),
(
"omp",
Some("off"),
&["minimal", "low", "medium", "high", "xhigh"],
),
("cline", Some("none"), &["low", "medium", "high"]),
("aider", Some("none"), EFFORT_LEVELS),
("copilot", None, LOW_TO_MAX),
("copilot-cli", None, LOW_TO_MAX),
("hermes", Some("none"), EFFORT_LEVELS),
("qwen", Some("none"), LOW_TO_MAX),
("grok", Some("none"), EFFORT_LEVELS),
("dsh", Some("off"), EFFORT_LEVELS),
];
fn spell_variant<'a>(integration: &str, variant: &'a str) -> anyhow::Result<&'a str> {
let name = integration.to_lowercase();
if name == "opencode" {
return Ok(variant);
}
if let Some((_, why)) = VARIANT_UNSUPPORTED.iter().find(|(id, _)| *id == name) {
anyhow::bail!("--variant does not work with {name}: {why}");
}
let Some(&(_, off, levels)) = VARIANT_SPELLINGS.iter().find(|(id, ..)| *id == name) else {
return Err(unknown_integration(&name));
};
let spelled = match variant {
"none" => off,
"thinking" => Some("medium"),
level => levels.iter().copied().find(|l| *l == level),
};
spelled.ok_or_else(|| {
let takes: Vec<&str> = off
.map(|_| "none")
.into_iter()
.chain(levels.iter().copied())
.chain(Some("thinking"))
.collect();
anyhow::anyhow!(
"{name} cannot start at --variant {variant}; it takes {}",
takes.join(", ")
)
})
}
struct Effort<'a> {
default: &'a str,
levels: Vec<&'a str>,
}
fn effort_args(integration: &str, effort: &str) -> Vec<String> {
let flags: &[&str] = match integration {
"claude" | "grok" => &["--effort"],
"copilot" | "copilot-cli" => &["--reasoning-effort"],
"pi" | "omp" | "cline" => &["--thinking"],
"hermes" => &["--reasoning"],
"aider" => &["--no-check-model-accepts-settings", "--reasoning-effort"],
"codex" => return vec!["-c".into(), format!("model_reasoning_effort={effort}")],
_ => return Vec::new(),
};
flags
.iter()
.copied()
.chain(Some(effort))
.map(String::from)
.collect()
}
#[allow(clippy::too_many_arguments)]
fn launch(
name: &str,
model: &str,
api_key: &str,
thinking: Option<&Thinking>,
variant: Option<&str>,
vision: bool,
context_window: Option<u64>,
max_output: Option<u32>,
extra_args: &[String],
optimizer: Optimizer,
) -> anyhow::Result<()> {
let name = name.to_lowercase();
let widened = variant
.filter(|_| thinking.is_none())
.map(unknown_levels_with);
let thinking = widened.as_ref().or(thinking);
if let Some(variant) = variant {
check_variant(model, thinking, variant)?;
}
let effort = variant.map(|v| spell_variant(&name, v)).transpose()?;
let listed = effort.map(|default| Effort {
default,
levels: thinking_choices(thinking)
.into_iter()
.filter_map(|c| spell_variant(&name, c).ok())
.collect(),
});
let extra_args = &[
effort.map_or_else(Vec::new, |e| effort_args(&name, e)),
extra_args.to_vec(),
]
.concat();
let reasons = variant.is_some()
|| thinking
.and_then(Thinking::template)
.is_some_and(|t| t.thinks);
match name.as_str() {
"claude" => claude::launch_claude(model, api_key, context_window, extra_args, optimizer),
"opencode" => opencode::launch_opencode(
model,
api_key,
thinking,
variant,
vision,
context_window,
max_output,
extra_args,
optimizer,
),
"codex" => codex::launch_codex(
model,
api_key,
vision,
context_window,
extra_args,
optimizer,
),
"pi" => pi::launch_pi(model, reasons, vision, context_window, extra_args),
"omp" => omp::launch_omp(model, reasons, vision, context_window, extra_args),
"cline" => cline::launch_cline(model, extra_args),
"aider" => aider::launch_aider(model, api_key, extra_args),
"copilot" | "copilot-cli" => copilot::launch_copilot(model, api_key, extra_args),
"droid" => droid::launch_droid(model, api_key, vision, max_output, extra_args),
"kimi" => kimi::launch_kimi(model, api_key, context_window, extra_args),
"gemini" => gemini::launch_gemini(model, api_key, extra_args),
"agy" => agy::launch_agy(model, api_key, extra_args),
"hermes" => hermes::launch_hermes(model, vision, extra_args),
"openclaw" => openclaw::launch_openclaw(model, context_window, extra_args),
"qwen" => qwen::launch_qwen(model, api_key, vision, listed.as_ref(), extra_args),
"dsh" => dsh::launch_dsh(model, api_key, vision, listed.as_ref(), extra_args),
"goose" => goose::launch_goose(model, api_key, extra_args),
"goose-desktop" => goose_desktop::launch_goose_desktop(model, api_key, extra_args),
"grok" => grok::launch_grok(model, api_key, listed.as_ref(), extra_args),
"docker-agent" => docker_agent::launch_docker_agent(model, api_key, extra_args),
"vibe" => vibe::launch_vibe(model, api_key, context_window, extra_args),
other => Err(unknown_integration(other)),
}
}
fn check_variant(model: &str, thinking: Option<&Thinking>, variant: &str) -> anyhow::Result<()> {
let choices = thinking_choices(thinking);
let shown = if model.is_empty() { "the model" } else { model };
anyhow::ensure!(!choices.is_empty(), "{shown} does not think");
anyhow::ensure!(
choices.contains(&variant),
"{shown} has no variant {variant}; it has {}",
choices.join(", ")
);
Ok(())
}
fn unknown_integration(name: &str) -> anyhow::Error {
anyhow::anyhow!(
"unknown integration {name:?}\nRun 'llmman launch' without arguments to list supported integrations."
)
}
const CONFIGURED_BY_FILE: &[&str] = &[
"agy",
"cline",
"codex",
"docker-agent",
"dsh",
"droid",
"grok",
"hermes",
"omp",
"openclaw",
"pi",
"qwen",
];
fn sandbox_state(name: &str) -> anyhow::Result<Vec<sandbox::State>> {
use sandbox::State::{Dir, Files};
let home = dirs::home_dir().context("no home directory")?;
let xdg = |var: &str, default: &str| xdg_dir(&home, var, default);
let config = xdg("XDG_CONFIG_HOME", ".config");
let data = xdg("XDG_DATA_HOME", ".local/share");
let state = xdg("XDG_STATE_HOME", ".local/state");
Ok(match name {
"claude" => match env_dir("CLAUDE_CONFIG_DIR") {
Some(dir) => vec![Dir(dir)],
None => vec![Dir(home.join(".claude")), Files(home.join(".claude.json"))],
},
"opencode" => vec![
Dir(config.join("opencode")),
Dir(data.join("opencode")),
Dir(opencode::opencode_state_dir()?),
Dir(xdg("XDG_CACHE_HOME", ".cache").join("opencode")),
],
"codex" => vec![Dir(codex::codex_dir()?)],
"pi" => vec![Dir(pi::pi_agent_dir()?)],
"omp" => vec![Dir(omp::omp_agent_dir()?)],
"cline" => vec![Dir(cline::cline_dir()?)],
"aider" => vec![Dir(home.join(".aider"))],
"copilot" | "copilot-cli" => vec![
Dir(env_dir("COPILOT_HOME").unwrap_or_else(|| home.join(".copilot"))),
Dir(env_dir("GH_CONFIG_DIR").unwrap_or_else(|| config.join("gh"))),
],
"droid" => vec![Dir(droid::droid_home()?)],
"kimi" => vec![Dir(home.join(".kimi"))],
"vibe" => vec![Dir(
env_dir("VIBE_HOME").unwrap_or_else(|| home.join(".vibe"))
)],
"gemini" => vec![Dir(home.join(".gemini"))],
"agy" => vec![Dir(agy::agy_settings_dir()?)],
"hermes" => vec![Dir(hermes::hermes_home()?)],
"openclaw" => std::iter::once(home.join(".openclaw"))
.chain(Some(home.join(".clawdbot")).filter(|d| d.is_dir()))
.map(Dir)
.collect(),
"qwen" => vec![Dir(qwen::qwen_home()?)],
"dsh" => vec![Dir(dsh::dsh_config_dir()?)],
"goose" | "goose-desktop" => {
let mut dirs = vec![
Dir(config.join("goose")),
Dir(data.join("goose")),
Dir(state.join("goose")),
];
if name == "goose-desktop" {
dirs.push(Dir(goose_desktop::goose_desktop_user_data(&home, &config)));
if cfg!(target_os = "macos") {
dirs.push(Files(
home.join("Library")
.join("Preferences")
.join("com.electron.goose.plist"),
));
}
}
dirs
}
"grok" => vec![Dir(grok::grok_home()?)],
"docker-agent" => vec![
Dir(docker_agent::docker_agent_config_dir()?),
Dir(home.join(".cagent")),
],
other => return Err(unknown_integration(other)),
})
}
fn node_user_profile() -> Option<PathBuf> {
cfg!(windows).then(|| env_dir("USERPROFILE")).flatten()
}
fn xdg_dir(home: &Path, var: &str, default: &str) -> PathBuf {
env_dir(var).unwrap_or_else(|| home.join(default))
}
enum Thinking {
Template(ThinkingControls),
Listed(Vec<String>),
}
impl Thinking {
fn choices(&self) -> Vec<&str> {
match self {
Thinking::Template(controls) => controls.choices(),
Thinking::Listed(levels) => levels.iter().map(String::as_str).collect(),
}
}
fn template(&self) -> Option<&ThinkingControls> {
match self {
Thinking::Template(controls) => Some(controls),
Thinking::Listed(_) => None,
}
}
}
const PORTABLE_THINKING_LEVELS: &[&str] = &["none", "low", "medium", "high"];
fn thinking_choices(thinking: Option<&Thinking>) -> Vec<&str> {
match thinking {
Some(thinking) => thinking.choices(),
None => PORTABLE_THINKING_LEVELS.to_vec(),
}
}
fn unknown_levels_with(variant: &str) -> Thinking {
let levels = std::iter::once("none")
.chain(EFFORT_LEVELS.iter().copied())
.filter(|l| PORTABLE_THINKING_LEVELS.contains(l) || *l == variant)
.map(String::from)
.collect();
Thinking::Listed(levels)
}
fn local_context_window(model: &str, trained: Option<u64>) -> Option<u64> {
crate::daemon::loaded_context_length(model)
.or_else(|| served_context_window(super::serve::context_length_from_env(), trained))
}
fn pair_context_window(local: Option<u64>, hosted: Option<u64>) -> Option<u64> {
match (local, hosted) {
(Some(local), Some(hosted)) => Some(local.max(hosted)),
(window, None) | (None, window) => window,
}
}
fn served_context_window(env: Option<u32>, trained: Option<u64>) -> Option<u64> {
match env {
Some(0) => trained,
Some(explicit) => Some(u64::from(explicit)),
None => trained.map(|trained| trained.min(u64::from(super::serve::DEFAULT_CTX_SIZE))),
}
}
fn exec_with_env(bin: &Path, args: &[String], extra_env: &[(&str, &str)]) -> anyhow::Result<()> {
exec_with_env_removing(bin, args, extra_env, &[])
}
fn exec_with_owned_env(bin: &Path, args: &[String], env: &[(&str, String)]) -> anyhow::Result<()> {
let env: Vec<(&str, &str)> = env.iter().map(|(k, v)| (*k, v.as_str())).collect();
exec_with_env(bin, args, &env)
}
fn exec_with_env_removing(
bin: &Path,
args: &[String],
extra_env: &[(&str, &str)],
remove_env: &[&str],
) -> anyhow::Result<()> {
let code = run_with_env_removing(bin, args, extra_env, remove_env);
hdrm::stop();
std::process::exit(code?);
}
fn run_with_env(bin: &Path, args: &[String], extra_env: &[(&str, &str)]) -> anyhow::Result<i32> {
run_with_env_removing(bin, args, extra_env, &[])
}
fn run_with_env_removing(
bin: &Path,
args: &[String],
extra_env: &[(&str, &str)],
remove_env: &[&str],
) -> anyhow::Result<i32> {
let mut overlay = vec![("OLLAMA_HOST".to_string(), server())];
overlay.extend(
extra_env
.iter()
.map(|(k, v)| (k.to_string(), v.to_string())),
);
if sandbox::active() {
return sandbox::run(bin, args, &overlay, remove_env);
}
let mut cmd = Command::new(bin);
cmd.args(args);
cmd.stdin(std::process::Stdio::inherit());
cmd.stdout(std::process::Stdio::inherit());
cmd.stderr(std::process::Stdio::inherit());
cmd.envs(overlay);
for name in remove_env {
cmd.env_remove(name);
}
let status = cmd
.status()
.with_context(|| format!("failed to run {}", bin.display()))?;
Ok(status.code().unwrap_or(1))
}
fn server() -> String {
sandbox::agent_server()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn check_installed_leaves_cline_and_unknown_names_alone() {
assert!(check_installed("cline").is_ok());
assert!(check_installed("not-an-integration").is_ok());
}
#[test]
fn agy_is_listed_as_an_integration() {
let agy = INTEGRATIONS.iter().find(|i| i.name == "agy").unwrap();
assert_eq!(agy.binary, "agy");
}
#[test]
fn copilot_is_the_standalone_model_required_byok_integration() {
let copilot = INTEGRATIONS.iter().find(|i| i.name == "copilot").unwrap();
assert_eq!(copilot.binary, "copilot");
for id in ["copilot", "copilot-cli"] {
assert!(MODEL_REQUIRED.contains(&id));
assert!(MODEL_FLAG_FORWARDED.contains(&id));
assert!(!PROVIDER_UNSUPPORTED.iter().any(|(name, _)| *name == id));
assert_eq!(effort_args(id, "high"), ["--reasoning-effort", "high"]);
}
}
#[test]
fn droid_is_a_file_configured_model_required_integration() {
let droid = INTEGRATIONS.iter().find(|i| i.name == "droid").unwrap();
assert_eq!(droid.binary, "droid");
assert!(MODEL_REQUIRED.contains(&"droid"));
assert!(MODEL_FLAG_FORWARDED.contains(&"droid"));
assert!(CONFIGURED_BY_FILE.contains(&"droid"));
assert!(check_provider_supported("droid").is_ok());
assert!(VARIANT_UNSUPPORTED.iter().any(|(name, _)| *name == "droid"));
}
#[test]
fn every_provider_unsupported_integration_is_a_real_one() {
for (id, why) in PROVIDER_UNSUPPORTED {
assert!(integration(id).is_some(), "{id} is not an integration");
assert!(!why.is_empty(), "{id} has no reason");
assert!(check_provider_supported(id).is_err(), "{id} was accepted");
assert!(check_provider_supported(&id.to_uppercase()).is_err());
}
for id in PROVIDER_NEEDS_DAEMON_KEY {
assert!(
INTEGRATIONS.iter().any(|i| i.name == *id),
"{id} is not an integration"
);
assert!(
!PROVIDER_UNSUPPORTED.iter().any(|(u, _)| u == id),
"{id} is both refused outright and expected to work"
);
}
}
#[test]
fn every_integration_has_sandbox_state() {
for i in INTEGRATIONS {
let state = sandbox_state(i.name).unwrap();
assert!(!state.is_empty(), "{} has no sandbox state", i.name);
}
assert!(sandbox_state("copilot-cli").is_ok());
assert!(sandbox_state("nope").is_err());
for id in CONFIGURED_BY_FILE {
assert!(
INTEGRATIONS.iter().any(|i| i.name == *id),
"{id} is not an integration"
);
}
}
#[test]
fn sandbox_state_covers_where_the_launchers_write() {
let covers = |name: &str, written: PathBuf| {
let state = sandbox_state(name).unwrap();
assert!(
state.iter().any(|s| matches!(
s,
sandbox::State::Dir(dir) if written.starts_with(dir)
)),
"{name}'s {} is outside its sandbox state {state:?}",
written.display()
);
};
covers("codex", codex::codex_dir().unwrap());
covers(
"opencode",
opencode::opencode_state_dir().unwrap().join("model.json"),
);
covers("pi", pi::pi_agent_dir().unwrap());
covers("omp", omp::omp_agent_dir().unwrap());
covers("cline", cline::cline_data_dir().unwrap());
covers("agy", agy::agy_settings_dir().unwrap());
covers("hermes", hermes::hermes_home().unwrap());
covers("qwen", qwen::qwen_home().unwrap());
covers("dsh", dsh::dsh_config_dir().unwrap());
covers("grok", grok::grok_home().unwrap().join("llmman"));
covers(
"docker-agent",
docker_agent::docker_agent_config_dir().unwrap(),
);
covers(
"openclaw",
dirs::home_dir()
.unwrap()
.join(".openclaw")
.join("openclaw.json"),
);
}
#[test]
fn provider_models_are_encoded_under_the_remote_prefix() {
assert_eq!(
providers::format_remote_ref("openrouter", "qwen/qwen3-coder"),
"llmman.provider/openrouter/qwen/qwen3-coder"
);
assert_eq!(
providers::split_remote_ref(&providers::format_remote_ref("groq", "llama-3.3-70b")),
Some(("groq", "llama-3.3-70b"))
);
}
#[test]
fn local_models_are_unaffected_by_the_remote_prefix() {
for local in ["qwen3.5:0.8b", "hf.co/unsloth/Qwen3.5-0.8B-GGUF"] {
let resolved = crate::shortnames::resolve_ollama_api(local).unwrap();
assert!(
!providers::is_remote_ref(&resolved),
"{local} resolved to a provider-routed reference: {resolved}"
);
}
}
#[test]
fn model_required_integrations_are_refused_without_a_model() {
let none: Vec<String> = vec![];
for id in MODEL_REQUIRED {
assert!(integration(id).is_some(), "{id} is not an integration");
assert!(check_model_flag(id, None, None, None, &none).is_err());
assert!(check_model_flag(id, Some(" "), None, None, &none).is_err());
assert!(check_model_flag(&id.to_uppercase(), None, None, None, &none).is_err());
let err = check_model_flag(id, None, Some("openrouter"), None, &none).unwrap_err();
assert!(
err.to_string().contains("--provider openrouter --model"),
"{err}"
);
assert!(check_model_flag(id, Some("m"), None, None, &none).is_ok());
let forwarded = vec!["--model".to_string(), "theirs".to_string()];
assert!(check_model_flag(id, Some("m"), None, None, &forwarded).is_ok());
}
assert!(check_model_flag("claude", None, None, None, &none).is_ok());
for id in MODEL_FLAG_FORWARDED {
assert!(integration(id).is_some(), "{id} is not an integration");
}
assert!(!MODEL_FLAG_FORWARDED.contains(&"dsh"));
assert!(MODEL_FLAG_FORWARDED.contains(&"claude"));
assert!(!MODEL_REQUIRED.contains(&"claude"));
}
#[test]
fn goose_carries_its_own_key_so_provider_works() {
assert!(INTEGRATIONS.iter().any(|i| i.name == "goose"));
assert!(check_provider_supported("goose").is_ok());
assert!(!PROVIDER_NEEDS_DAEMON_KEY.contains(&"goose"));
}
#[test]
fn find_on_path_unless_consults_its_predicate() {
let present = ["cargo", "sh", "cmd"]
.into_iter()
.find(|b| find_on_path(b).is_some());
let Some(present) = present else {
eprintln!("skipping: no known binary on PATH to test against");
return;
};
let found = find_on_path(present).unwrap();
assert!(found.is_file());
assert_eq!(find_on_path_unless(present, |_| true), None);
assert_eq!(
find_on_path_unless(present, |p| p != found),
Some(found.clone())
);
assert_eq!(find_on_path("llmman-no-such-binary-xyz"), None);
assert_eq!(
find_on_path_unless("llmman-no-such-binary-xyz", |_| false),
None
);
}
#[test]
fn goose_desktop_sandbox_state_covers_the_electron_user_data() {
let desktop = sandbox_state("goose-desktop").unwrap();
let cli = sandbox_state("goose").unwrap();
assert!(desktop.len() > cli.len(), "{desktop:?}");
assert!(
desktop.iter().any(|s| matches!(
s,
sandbox::State::Dir(d) if d.file_name() == Some(std::ffi::OsStr::new("Goose"))
)),
"no userData directory in {desktop:?}"
);
if cfg!(target_os = "macos") {
assert!(
desktop.iter().any(|s| matches!(
s,
sandbox::State::Files(f) if f.extension() == Some(std::ffi::OsStr::new("plist"))
)),
"no preferences file in {desktop:?}"
);
}
}
#[test]
fn goose_desktop_carries_its_own_key_so_provider_works() {
assert!(INTEGRATIONS.iter().any(|i| i.name == "goose-desktop"));
assert!(check_provider_supported("goose-desktop").is_ok());
assert!(!PROVIDER_NEEDS_DAEMON_KEY.contains(&"goose-desktop"));
assert!(!CONFIGURED_BY_FILE.contains(&"goose-desktop"));
assert!(!MODEL_FLAG_FORWARDED.contains(&"goose-desktop"));
assert!(MODEL_REQUIRED.contains(&"goose-desktop"));
}
#[test]
fn goose_desktop_launches_without_a_model_only_for_dictation() {
let none: Vec<String> = vec![];
let speech = Some("hf.co/ggml-org/Voxtral-Mini-3B-2507-GGUF:Q4_K_M");
for id in ["goose-desktop", "GOOSE-DESKTOP"] {
assert!(check_model_flag(id, None, None, speech, &none).is_ok());
assert!(check_model_flag(id, Some("m"), None, speech, &none).is_ok());
for blank in [None, Some(""), Some(" \t\n")] {
let err = check_model_flag(id, None, None, blank, &none).unwrap_err();
assert!(err
.to_string()
.contains("--model <model>, or set OPENAI_TRANSCRIPTION_MODEL="));
}
let err = check_model_flag(id, None, Some("openrouter"), speech, &none).unwrap_err();
assert!(err
.to_string()
.contains("--provider openrouter --model <model>"));
assert!(!err.to_string().contains("OPENAI_TRANSCRIPTION_MODEL"));
}
for id in MODEL_REQUIRED.iter().filter(|id| **id != "goose-desktop") {
assert!(check_model_flag(id, None, None, speech, &none).is_err());
}
}
#[test]
fn cline_is_model_required_and_supports_provider_routes() {
assert!(INTEGRATIONS.iter().any(|i| i.name == "cline"));
assert!(MODEL_REQUIRED.contains(&"cline"));
assert!(MODEL_FLAG_FORWARDED.contains(&"cline"));
assert!(!PROVIDER_UNSUPPORTED.iter().any(|(id, _)| *id == "cline"));
assert!(PROVIDER_NEEDS_DAEMON_KEY.contains(&"cline"));
assert!(check_provider_supported("cline").is_ok());
}
#[test]
fn grok_is_model_required_and_refuses_unrepresentable_provider_routes() {
assert!(INTEGRATIONS.iter().any(|i| i.name == "grok"));
assert!(MODEL_REQUIRED.contains(&"grok"));
assert!(MODEL_FLAG_FORWARDED.contains(&"grok"));
let error = check_provider_supported("grok").unwrap_err().to_string();
assert!(error.contains("model catalog"), "{error}");
assert!(!PROVIDER_NEEDS_DAEMON_KEY.contains(&"grok"));
}
#[test]
fn has_flag_takes_the_exact_and_joined_forms_only() {
let args = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
assert!(has_flag(&args(&["--model", "x"]), "--model", Some("-m")));
assert!(has_flag(&args(&["--model=x"]), "--model", Some("-m")));
assert!(has_flag(&args(&["-m", "x"]), "--model", Some("-m")));
assert!(has_flag(&args(&["-m=x"]), "--model", Some("-m")));
assert!(!has_flag(&args(&["-sm", "x"]), "--model", Some("-m")));
assert!(!has_flag(
&args(&["--model-context", "x"]),
"--model",
Some("-m")
));
}
#[test]
fn forwarded_model_flag_is_seen_for_each_integration_that_yields() {
let args = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
let model = args(&["--model", "other/model"]);
for name in MODEL_FLAG_FORWARDED {
assert!(has_forwarded_model_flag(name, &model), "{name}");
}
assert!(!has_forwarded_model_flag("docker-agent", &model));
assert!(!has_forwarded_model_flag("dsh", &model));
let short = args(&["-m", "other/model"]);
assert!(!has_forwarded_model_flag("claude", &short));
assert!(!has_forwarded_model_flag("copilot", &short));
assert!(has_forwarded_model_flag("grok", &short));
let message = args(&["--", "--model", "other/model"]);
assert!(!has_forwarded_model_flag("claude", &message));
assert!(has_forwarded_model_flag(
"claude",
&args(&["--model", "other/model", "--", "hi"])
));
}
#[test]
fn the_integrations_that_declare_a_window_are_the_ones_that_take_one() {
assert!(declares_context_window("opencode"));
assert!(declares_context_window("codex"));
assert!(declares_context_window("OpenCode"), "matched case-blind");
assert!(declares_context_window("pi"));
assert!(declares_context_window("omp"));
assert!(declares_context_window("kimi"));
assert!(declares_context_window("openclaw"));
assert!(declares_context_window("claude"));
assert!(!declares_context_window("aider"));
}
#[test]
fn pair_context_window_takes_whichever_half_holds_more() {
assert_eq!(
pair_context_window(Some(262_144), Some(1 << 20)),
Some(1 << 20)
);
assert_eq!(
pair_context_window(Some(1 << 20), Some(200_000)),
Some(1 << 20)
);
assert_eq!(pair_context_window(Some(262_144), None), Some(262_144));
assert_eq!(pair_context_window(None, Some(200_000)), Some(200_000));
assert_eq!(pair_context_window(None, None), None);
}
#[test]
fn served_context_window_prefers_the_environment_then_the_trained_context() {
let cases = [
(Some(16384), Some(32768), Some(16384)),
(Some(65536), Some(32768), Some(65536)),
(Some(16384), None, Some(16384)),
(None, Some(32768), Some(32768)),
(Some(0), Some(32768), Some(32768)),
(Some(0), Some(1 << 20), Some(1 << 20)),
(
None,
Some(1 << 20),
Some(u64::from(super::super::serve::DEFAULT_CTX_SIZE)),
),
(Some(1 << 20), Some(1 << 20), Some(1 << 20)),
(Some(0), None, None),
(None, None, None),
];
for (env, trained, want) in cases {
assert_eq!(
served_context_window(env, trained),
want,
"env={env:?} trained={trained:?}"
);
}
}
#[test]
fn dsh_is_a_real_integration_and_not_on_a_provider_refusal_list() {
assert!(INTEGRATIONS.iter().any(|i| i.name == "dsh"));
assert!(!PROVIDER_UNSUPPORTED.iter().any(|(id, _)| *id == "dsh"));
assert!(!PROVIDER_NEEDS_DAEMON_KEY.contains(&"dsh"));
}
#[test]
fn docker_agent_is_a_real_model_required_integration_provider_can_drive() {
let entry = INTEGRATIONS
.iter()
.find(|i| i.name == "docker-agent")
.expect("docker-agent is not an integration");
assert_eq!(entry.binary, "docker-agent");
assert!(MODEL_REQUIRED.contains(&"docker-agent"));
assert!(!MODEL_FLAG_FORWARDED.contains(&"docker-agent"));
assert!(check_provider_supported("docker-agent").is_ok());
assert!(!PROVIDER_NEEDS_DAEMON_KEY.contains(&"docker-agent"));
}
#[test]
fn every_integration_name_fits_the_listings_column() {
let longest = INTEGRATIONS.iter().map(|i| i.name.len()).max().unwrap();
assert!(
longest <= 14,
"{longest}-character name overflows the `{{:<14}}` column in print_integrations"
);
}
#[test]
fn a_variant_is_refused_only_for_a_model_with_known_levels() {
let check = |thinking: Option<&Thinking>, variant: &str| {
check_variant("m", thinking, variant).map_err(|e| e.to_string())
};
assert!(check(None, "xhigh").is_err(), "the guess refuses");
for variant in ["none", "minimal", "low", "high", "xhigh", "max"] {
let widened = unknown_levels_with(variant);
check(Some(&widened), variant).unwrap();
}
let thinking = unknown_levels_with("thinking");
assert!(check(Some(&thinking), "thinking").is_err());
let widened = unknown_levels_with("xhigh");
let variants = opencode::opencode_variants(Some(&widened));
let names: Vec<_> = variants.iter().map(|(name, _)| *name).collect();
assert_eq!(names, ["none", "low", "medium", "high", "xhigh"]);
assert_eq!(
variants[4].1,
serde_json::json!({ "reasoningEffort": "xhigh" })
);
let listed = Thinking::Listed(["low", "high"].map(String::from).to_vec());
assert!(check(Some(&listed), "high").is_ok());
let err = check(Some(&listed), "xhigh").unwrap_err();
assert!(
err.contains("m has no variant xhigh; it has low, high"),
"{err}"
);
let none = Thinking::Listed(Vec::new());
assert!(check(Some(&none), "low")
.unwrap_err()
.contains("does not think"));
}
#[test]
fn spell_variant_uses_each_integrations_own_words() {
let ok = |name, variant| spell_variant(name, variant).unwrap();
assert_eq!(ok("opencode", "thinking"), "thinking");
assert_eq!(ok("codex", "none"), "none");
assert_eq!(ok("pi", "none"), "off");
assert_eq!(ok("dsh", "none"), "off");
assert_eq!(ok("claude", "max"), "max");
assert_eq!(ok("cline", "thinking"), "medium");
assert_eq!(ok("Claude", "high"), "high");
}
#[test]
fn spell_variant_refuses_what_the_integration_cannot_start_at() {
let err = |name, variant| spell_variant(name, variant).unwrap_err().to_string();
let claude = err("claude", "none");
assert!(
claude.contains("low, medium, high, xhigh, max, thinking"),
"{claude}"
);
assert!(!claude.contains("none,"), "{claude}");
assert!(err("pi", "xhigh").contains("none, minimal"));
assert!(err("cline", "minimal").contains("cline cannot start"));
assert!(err("kimi", "high").contains("--variant does not work with kimi"));
assert!(err("nope", "high").contains("unknown integration"));
}
#[test]
fn every_integration_takes_or_refuses_a_variant() {
for i in INTEGRATIONS {
let spelled = spell_variant(i.name, "thinking").is_ok();
let refused = VARIANT_UNSUPPORTED.iter().any(|(id, _)| *id == i.name);
let configured = matches!(i.name, "opencode" | "qwen" | "dsh");
assert!(spelled != refused, "{}", i.name);
assert!(
refused || configured || !effort_args(i.name, "medium").is_empty(),
"{} is spelled but never told",
i.name
);
}
}
#[test]
fn effort_args_lead_with_each_integrations_flag() {
let args = |name| effort_args(name, "high");
assert_eq!(args("claude"), ["--effort", "high"]);
assert_eq!(args("pi"), ["--thinking", "high"]);
assert_eq!(args("hermes"), ["--reasoning", "high"]);
assert_eq!(args("codex"), ["-c", "model_reasoning_effort=high"]);
assert_eq!(
args("aider"),
[
"--no-check-model-accepts-settings",
"--reasoning-effort",
"high"
]
);
assert!(args("qwen").is_empty());
}
#[test]
fn launch_variant_is_one_of_llmmans() {
#[derive(clap::Parser)]
struct Cli {
#[command(flatten)]
args: LaunchArgs,
}
let parse = |v: &str| <Cli as clap::Parser>::try_parse_from(["l", "pi", "--variant", v]);
assert_eq!(
parse("xhigh").unwrap().args.variant.as_deref(),
Some("xhigh")
);
assert!(parse("turbo").is_err());
let args = <Cli as clap::Parser>::try_parse_from([
"l",
"qwen",
"-m",
"a",
"--variant",
"high",
"--",
"--model",
"b",
])
.unwrap()
.args;
let err = run(&args).unwrap_err().to_string();
assert!(err.contains("not after --"), "{err}");
}
#[cfg(not(windows))]
#[test]
fn opencode_variant_is_refused_where_the_sandbox_gets_no_files() {
#[derive(clap::Parser)]
struct Cli {
#[command(flatten)]
args: LaunchArgs,
}
let args = <Cli as clap::Parser>::try_parse_from([
"l",
"opencode",
"--sandbox",
"openshell",
"--variant",
"high",
])
.unwrap()
.args;
let err = run(&args).unwrap_err().to_string();
assert!(err.contains("openshell cannot run opencode"), "{err}");
}
#[test]
fn a_bare_sandbox_is_sbx() {
assert_eq!(launch_args(&["claude"]).sandbox, None);
assert_eq!(
launch_args(&["claude", "--sandbox"]).sandbox,
Some(Sandbox::Sbx)
);
assert_eq!(
launch_args(&["claude", "--sandbox", "docker"]).sandbox,
Some(Sandbox::Docker)
);
let args = launch_args(&["claude", "--sandbox", "--model", "qwen3.8", "--", "hi"]);
assert_eq!(args.sandbox, Some(Sandbox::Sbx));
assert_eq!(args.model.as_deref(), Some("qwen3.8"));
assert_eq!(args.extra_args, ["hi"]);
}
#[test]
fn the_optimizer_defaults_to_none_and_takes_none_tk_cvmn_or_hdrm() {
assert_eq!(launch_args(&["claude"]).optimizer, Optimizer::None);
assert_eq!(
launch_args(&["claude", "--optimizer", "none"]).optimizer,
Optimizer::None
);
assert_eq!(
launch_args(&["claude", "--optimizer", "tk"]).optimizer,
Optimizer::Tk
);
assert_eq!(
launch_args(&["claude", "--optimizer=tk", "--", "-p", "hi"]).optimizer,
Optimizer::Tk
);
assert_eq!(
launch_args(&["claude", "--optimizer", "cvmn"]).optimizer,
Optimizer::Cvmn
);
assert_eq!(
launch_args(&["claude", "--optimizer", "hdrm"]).optimizer,
Optimizer::Hdrm
);
let args = launch_args(&["claude", "--", "--optimizer", "tk"]);
assert_eq!(args.optimizer, Optimizer::None);
assert_eq!(args.extra_args, ["--optimizer", "tk"]);
}
#[test]
fn a_bad_optimizer_is_rejected_by_the_parser() {
#[derive(clap::Parser, Debug)]
struct Cli {
#[command(flatten)]
args: LaunchArgs,
}
for bad in ["TK", "turbo", "", "none,tk"] {
let err = <Cli as clap::Parser>::try_parse_from(["l", "claude", "--optimizer", bad])
.unwrap_err()
.to_string();
assert!(err.contains("--optimizer"), "{bad}: {err}");
}
let help = <Cli as clap::CommandFactory>::command()
.render_long_help()
.to_string();
assert!(help.contains("--optimizer <OPTIMIZER>"), "{help}");
assert!(help.contains("none"), "{help}");
assert!(help.contains("tk"), "{help}");
assert!(help.contains("cvmn"), "{help}");
assert!(help.contains("hdrm"), "{help}");
assert!(help.contains("[default: none]"), "{help}");
}
#[test]
fn tk_is_refused_for_other_integrations_before_anything_starts() {
for name in [
"codex",
"aider",
"goose",
"cline",
"gemini",
"docker-agent",
"copilot-cli",
] {
let args = launch_args(&[name, "--model", "m", "--optimizer", "tk"]);
let err = run(&args).unwrap_err().to_string();
let canonical = canonical_integration(name).unwrap();
assert!(
err.contains(&format!("does not work with {canonical}")),
"{name}: {err}"
);
assert!(
err.contains("only claude, opencode can use it"),
"{name}: {err}"
);
}
}
#[test]
fn cvmn_is_refused_for_other_integrations_before_anything_starts() {
let args = launch_args(&["aider", "--model", "m", "--optimizer", "cvmn"]);
let err = run(&args).unwrap_err().to_string();
assert!(err.contains("does not work with aider"), "{err}");
assert!(
err.contains("only claude, codex, opencode can use it"),
"{err}"
);
}
#[test]
fn tk_is_refused_with_a_sandbox_before_sbx_is_reached() {
for sandbox in [
&["--sandbox"][..],
&["--sandbox", "sbx"],
&["--sandbox", "docker"],
] {
let mut argv = vec!["claude", "--model", "m", "--optimizer", "tk"];
argv.extend_from_slice(sandbox);
let err = run(&launch_args(&argv)).unwrap_err().to_string();
assert!(
err.contains("--optimizer tk does not work with --sandbox"),
"{err}"
);
}
}
#[test]
fn tk_is_refused_beside_claude_flags_it_cannot_honor() {
let args = launch_args(&[
"claude",
"--model",
"m",
"--optimizer",
"tk",
"--",
"--settings",
"mine.json",
]);
let err = run(&args).unwrap_err().to_string();
assert!(err.contains("--settings"), "{err}");
}
#[test]
fn configured_defaults_leave_the_optimizer_alone() {
let (args, _) = applied(&["claude", "--optimizer", "tk"], &sonnet());
assert_eq!(args.optimizer, Optimizer::Tk);
let (args, _) = applied(&["claude"], &sonnet());
assert_eq!(args.optimizer, Optimizer::None);
}
fn launch_args(argv: &[&str]) -> LaunchArgs {
#[derive(clap::Parser)]
struct Cli {
#[command(flatten)]
args: LaunchArgs,
}
<Cli as clap::Parser>::try_parse_from(["l"].into_iter().chain(argv.iter().copied()))
.unwrap()
.args
}
fn applied(argv: &[&str], conf: &crate::config::LaunchConf) -> (LaunchArgs, Vec<String>) {
let args = launch_args(argv);
let name = args.integration.clone().unwrap();
apply_defaults(&args, &name, || Ok(conf.clone())).unwrap()
}
fn sonnet() -> crate::config::LaunchConf {
crate::config::launch_conf(Some("anthropic"), Some("claude-sonnet-5-5"), Some("xhigh"))
}
#[test]
fn configured_defaults_fill_every_flag_the_command_line_left_out() {
let (args, applied) = applied(&["opencode"], &sonnet());
assert_eq!(args.provider.as_deref(), Some("anthropic"));
assert_eq!(args.model.as_deref(), Some("claude-sonnet-5-5"));
assert_eq!(args.variant.as_deref(), Some("xhigh"));
assert_eq!(
applied,
[
"--provider anthropic",
"--model claude-sonnet-5-5",
"--variant xhigh"
]
);
let (args, _) = self::applied(
&["opencode", "--sandbox", "docker", "--", "run", "hi"],
&sonnet(),
);
assert_eq!(args.model.as_deref(), Some("claude-sonnet-5-5"));
assert_eq!(args.extra_args, ["run", "hi"]);
}
#[test]
fn nothing_configured_changes_nothing() {
let none = crate::config::LaunchConf::default();
let (args, applied) = applied(&["opencode", "-m", "qwen3.8", "--variant", "low"], &none);
assert!(applied.is_empty());
assert_eq!(args.model.as_deref(), Some("qwen3.8"));
assert_eq!(args.variant.as_deref(), Some("low"));
assert_eq!(args.provider, None);
}
#[test]
fn a_typed_variant_replaces_only_the_configured_variant() {
let (args, applied) = applied(&["opencode", "--variant", "low"], &sonnet());
assert_eq!(args.provider.as_deref(), Some("anthropic"));
assert_eq!(args.model.as_deref(), Some("claude-sonnet-5-5"));
assert_eq!(args.variant.as_deref(), Some("low"));
assert_eq!(
applied,
["--provider anthropic", "--model claude-sonnet-5-5"]
);
}
#[test]
fn a_typed_model_choice_turns_the_configured_set_off() {
for argv in [
&["opencode", "--model", "qwen3.8"][..],
&["opencode", "-m", "qwen3.8"],
&["opencode", "--provider", "openai"],
&["opencode", "-p", "openai", "--model", "gpt-5"],
&["opencode", "--overflow-provider", "openai"],
&["opencode", "--overflow-model", "gpt-5"],
] {
let typed = launch_args(argv);
let (args, applied) = applied(argv, &sonnet());
assert!(applied.is_empty(), "{argv:?}: {applied:?}");
assert_eq!(args.provider, typed.provider, "{argv:?}");
assert_eq!(args.model, typed.model, "{argv:?}");
assert_eq!(args.variant, None, "{argv:?}");
}
}
#[test]
fn a_forwarded_model_keeps_the_configured_model_but_not_its_variant() {
let (args, applied) = applied(&["qwen", "--", "--model", "b"], &sonnet());
assert_eq!(args.model.as_deref(), Some("claude-sonnet-5-5"));
assert_eq!(args.variant, None);
assert_eq!(
applied,
["--provider anthropic", "--model claude-sonnet-5-5"]
);
let (args, _) = self::applied(&["opencode", "--", "--model", "x"], &sonnet());
assert_eq!(args.variant.as_deref(), Some("xhigh"));
}
#[test]
fn unreadable_defaults_fail_only_a_launch_that_needs_them() {
let args = launch_args(&["opencode"]);
let err = apply_defaults(&args, "opencode", || Err("bad file")).unwrap_err();
assert!(err.to_string().contains("bad file"), "{err}");
for argv in [&["opencode", "-m", "x"][..], &["opencode", "-p", "x"]] {
let args = launch_args(argv);
apply_defaults(&args, "opencode", || Err("bad file")).expect("not consulted");
}
}
#[test]
fn canonical_integration_resolves_case_and_aliases() {
assert_eq!(canonical_integration("OpenCode"), Some("opencode"));
assert_eq!(canonical_integration("copilot-cli"), Some("copilot"));
assert_eq!(canonical_integration("nonesuch"), None);
for i in INTEGRATIONS {
assert_eq!(canonical_integration(i.name), Some(i.name));
}
}
}