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 claude;
mod codex;
mod common;
mod copilot;
mod goose;
mod goose_desktop;
mod openclaw;
mod opencode;
mod sandbox;
pub use sandbox::Sandbox;
#[derive(Args, Debug)]
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")]
pub sandbox: Option<Sandbox>,
#[arg(long, value_name = "VARIANT", value_parser = super::run::variant_parser())]
pub variant: Option<String>,
#[arg(last = true, value_name = "ARGS")]
pub extra_args: Vec<String>,
}
pub fn run(args: &LaunchArgs) -> anyhow::Result<()> {
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!(
!(MODEL_FLAG_FORWARDED.contains(&name.to_lowercase().as_str())
&& has_flag(&args.extra_args, "--model", Some("-m"))),
"--variant needs the model as llmman's --model, not after --"
);
spell_variant(name, variant)?;
}
if args.sandbox == Some(Sandbox::Sbx) {
return sandbox::run_sbx(
name,
args.model.as_deref(),
provider,
overflow,
&args.extra_args,
);
}
check_model_flag(name, args.model.as_deref(), provider, &args.extra_args)?;
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") {
ensure_cline_installed()?;
}
if name.eq_ignore_ascii_case("docker-agent") {
check_docker_agent_args(&args.extra_args)?;
}
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())
.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())
}
}
}
};
launch(
name,
&model,
&api_key,
thinking.as_ref(),
variant,
vision,
context_window,
max_output,
&args.extra_args,
)
}
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",
"docker-agent",
];
const MODEL_FLAG_FORWARDED: &[&str] = &["qwen", "goose", "grok", "cline", "omp"];
fn check_model_flag(
integration: &str,
model: Option<&str>,
provider: Option<&str>,
extra_args: &[String],
) -> anyhow::Result<()> {
let name = integration.to_lowercase();
if !MODEL_REQUIRED.contains(&name.as_str()) {
return Ok(());
}
let Some(model) = model.map(str::trim).filter(|m| !m.is_empty()) else {
let with_provider = provider.map_or(String::new(), |p| format!(" --provider {p}"));
anyhow::bail!("{name} needs a model: llmman launch {name}{with_provider} --model <model>");
};
if MODEL_FLAG_FORWARDED.contains(&name.as_str()) && has_flag(extra_args, "--model", Some("-m"))
{
eprintln!(
"[llmman] {name}: the --model after -- wins over --model {model}, the one llmman resolved"
);
}
Ok(())
}
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",
"it selects its own model rather than taking one from llmman",
),
("copilot", "it has no way to send a provider API key"),
("copilot-cli", "it has no way to send a provider API key"),
(
"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(),
"opencode" | "codex" | "pi" | "omp"
)
}
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: "gh",
},
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",
},
];
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> {
std::env::var_os(key)
.filter(|value| !value.is_empty())
.map(PathBuf::from)
}
fn find_integration_binary(i: &Integration) -> Option<PathBuf> {
match i.name {
"opencode" => opencode::find_opencode(),
"omp" => find_omp(),
"qwen" => find_qwen(),
"dsh" => find_dsh().map(|(bin, _)| bin),
"goose" => goose::find_goose(),
"goose-desktop" => goose_desktop::find_goose_desktop(),
"grok" => find_grok(),
"docker-agent" => find_docker_agent(),
_ => find_on_path(i.binary),
}
}
const CLINE_NPM_INSTALL_ARGS: &[&str] = &["install", "-g", "cline@latest"];
const CLINE_INSTALL_PROMPT: &str = "Cline is not installed. Install with npm? [y/N] ";
const CLINE_INSTALL_CANCELLED: &str = "cline installation cancelled";
fn ensure_cline_installed() -> anyhow::Result<()> {
use std::io::{BufRead, IsTerminal, Write};
if find_on_path("cline").is_some() {
return Ok(());
}
let npm = find_on_path("npm").ok_or_else(|| {
anyhow::anyhow!(
"cline is not installed and npm is not on PATH\n\n\
Install Node.js from https://nodejs.org/, then re-run:\n \
llmman launch cline"
)
})?;
anyhow::ensure!(
std::io::stdin().is_terminal() && std::io::stderr().is_terminal(),
"cline is not installed\n\nInstall it with:\n npm install -g cline@latest\n\n\
Then re-run:\n llmman launch cline"
);
eprint!("{CLINE_INSTALL_PROMPT}");
std::io::stderr().flush()?;
let mut answer = String::new();
std::io::stdin().lock().read_line(&mut answer)?;
anyhow::ensure!(accepts_prompt(&answer), CLINE_INSTALL_CANCELLED);
eprintln!("\nInstalling Cline...");
let status = Command::new(&npm)
.args(CLINE_NPM_INSTALL_ARGS)
.status()
.with_context(|| format!("failed to run {}", npm.display()))?;
anyhow::ensure!(status.success(), "failed to install cline: {status}");
let cline = find_on_path("cline").ok_or_else(|| {
anyhow::anyhow!(
"cline was installed but the binary was not found on PATH\n\n\
You may need to restart your shell"
)
})?;
let version = Command::new(&cline)
.arg("--version")
.status()
.with_context(|| format!("failed to run {} --version", cline.display()))?;
anyhow::ensure!(
version.success(),
"cline was installed but failed to start ({version})"
);
eprintln!("Cline installed successfully\n");
Ok(())
}
fn accepts_prompt(answer: &str) -> bool {
matches!(answer.trim().to_ascii_lowercase().as_str(), "y" | "yes")
}
const VARIANT_UNSUPPORTED: &[(&str, &str)] = &[
("kimi", "it picks its own model"),
("openclaw", "it only takes settings at onboarding"),
("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"),
];
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" | "copilot" | "copilot-cli" | "grok" => &["--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],
) -> 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, extra_args),
"opencode" => opencode::launch_opencode(
model,
api_key,
thinking,
variant,
vision,
context_window,
max_output,
extra_args,
),
"codex" => codex::launch_codex(model, api_key, vision, context_window, extra_args),
"pi" => launch_pi(model, reasons, vision, context_window, extra_args),
"omp" => launch_omp(model, reasons, vision, context_window, extra_args),
"cline" => launch_cline(model, extra_args),
"aider" => launch_aider(model, api_key, extra_args),
"copilot" | "copilot-cli" => copilot::launch_copilot(model, extra_args),
"kimi" => launch_simple("kimi", model, extra_args),
"gemini" => launch_gemini(model, api_key, extra_args),
"agy" => agy::launch_agy(model, api_key, extra_args),
"hermes" => launch_hermes(model, vision, extra_args),
"openclaw" => openclaw::launch_openclaw(model, extra_args),
"qwen" => launch_qwen(model, api_key, vision, listed.as_ref(), extra_args),
"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" => launch_grok(model, api_key, listed.as_ref(), extra_args),
"docker-agent" => launch_docker_agent(model, api_key, 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",
"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_agent_dir()?)],
"omp" => vec![Dir(omp_agent_dir()?)],
"cline" => vec![Dir(cline_dir()?)],
"aider" => vec![Dir(home.join(".aider"))],
"copilot" | "copilot-cli" => vec![
Dir(home.join(".copilot")),
Dir(env_dir("GH_CONFIG_DIR").unwrap_or_else(|| config.join("gh"))),
],
"kimi" => vec![Dir(home.join(".kimi"))],
"gemini" => vec![Dir(home.join(".gemini"))],
"agy" => vec![Dir(agy::agy_settings_dir()?)],
"hermes" => vec![Dir(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_home()?)],
"dsh" => vec![Dir(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_home()?)],
"docker-agent" => vec![Dir(docker_agent_config_dir()?), Dir(home.join(".cagent"))],
other => return Err(unknown_integration(other)),
})
}
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 launch_pi(
model: &str,
reasons: bool,
vision: bool,
context_window: Option<u64>,
extra_args: &[String],
) -> anyhow::Result<()> {
let bin = find_on_path("pi").ok_or_else(|| anyhow::anyhow!("pi is not installed"))?;
write_pi_config(model, reasons, vision, context_window)?;
exec_with_env(&bin, extra_args, &[])
}
fn launch_omp(
model: &str,
reasons: bool,
vision: bool,
context_window: Option<u64>,
extra_args: &[String],
) -> anyhow::Result<()> {
let bin = find_omp().ok_or_else(|| anyhow::anyhow!("omp is not installed"))?;
let server = server();
write_omp_config(model, reasons, vision, context_window, &server)?;
exec_with_env(
&bin,
&omp_args(model, extra_args),
&[("OLLAMA_BASE_URL", server.as_str())],
)
}
const OMP_PROVIDER: &str = "ollama";
const OMP_SETUP_VERSION: u64 = 2;
fn find_omp() -> Option<PathBuf> {
find_on_path("omp").or_else(|| omp_fallback_paths().into_iter().find(|path| path.is_file()))
}
fn omp_fallback_paths() -> Vec<PathBuf> {
let Some(home) = dirs::home_dir() else {
return Vec::new();
};
let dirs = [
home.join(".bun").join("bin"),
home.join(".local").join("bin"),
];
if cfg!(windows) {
return dirs
.into_iter()
.flat_map(|dir| {
WINDOWS_PATH_EXTS
.iter()
.map(move |ext| dir.join(format!("omp.{ext}")))
})
.collect();
}
dirs.into_iter().map(|dir| dir.join("omp")).collect()
}
fn omp_agent_dir() -> anyhow::Result<PathBuf> {
if let Some(dir) = configured_pi_agent_dir()? {
return Ok(dir);
}
let home = crate::config::home_dir().context("no home directory")?;
let config = std::env::var("PI_CONFIG_DIR")
.ok()
.filter(|dir| !dir.trim().is_empty())
.unwrap_or_else(|| ".omp".to_string());
let config = PathBuf::from(config.trim());
Ok(if config.is_absolute() {
config.join("agent")
} else {
home.join(config).join("agent")
})
}
fn write_omp_config(
model: &str,
reasons: bool,
vision: bool,
context_window: Option<u64>,
server: &str,
) -> anyhow::Result<()> {
let dir = omp_agent_dir()?;
write_omp_config_in_dir(&dir, model, reasons, vision, context_window, server)
}
fn write_omp_config_in_dir(
dir: &Path,
model: &str,
reasons: bool,
vision: bool,
context_window: Option<u64>,
server: &str,
) -> anyhow::Result<()> {
write_omp_models_config_at(
&dir.join("models.yml"),
model,
reasons,
vision,
context_window,
server,
)?;
common::write_yaml_merged(&dir.join("config.yml"), "omp", omp_config_merged)
}
fn omp_config_merged(existing: &serde_json::Value) -> serde_json::Value {
let mut config = existing.clone();
if let Some(config) = config.as_object_mut() {
let setup_version = config
.get("setupVersion")
.and_then(serde_json::Value::as_u64)
.unwrap_or_default()
.max(OMP_SETUP_VERSION);
config.insert("setupVersion".into(), serde_json::json!(setup_version));
}
config
}
fn write_omp_models_config_at(
path: &Path,
model: &str,
reasons: bool,
vision: bool,
context_window: Option<u64>,
server: &str,
) -> anyhow::Result<()> {
let entry = pi_model_entry(model, reasons, vision, context_window);
common::write_yaml_merged(path, "omp", |existing| {
omp_models_merged(existing, server, &entry)
})
}
fn omp_models_merged(
existing: &serde_json::Value,
server: &str,
entry: &serde_json::Value,
) -> serde_json::Value {
provider_models_merged(existing, OMP_PROVIDER, entry, true, |provider| {
provider.insert(
"baseUrl".into(),
serde_json::json!(format!("{}/v1", server.trim_end_matches('/'))),
);
provider.insert("api".into(), serde_json::json!("openai-responses"));
provider.remove("auth");
provider.insert(
"apiKey".into(),
serde_json::json!(providers::PLACEHOLDER_API_KEY),
);
provider.insert("authHeader".into(), serde_json::json!(true));
provider.insert("discovery".into(), serde_json::json!({ "type": "ollama" }));
})
}
fn omp_args(model: &str, extra_args: &[String]) -> Vec<String> {
let mut args = Vec::with_capacity(extra_args.len() + 2);
if !has_flag(extra_args, "--model", Some("-m")) {
args.extend(["--model".to_string(), format!("ollama/{model}")]);
}
args.extend_from_slice(extra_args);
args
}
const PI_PROVIDER: &str = "llmman";
fn configured_pi_agent_dir() -> anyhow::Result<Option<PathBuf>> {
let Some(dir) = std::env::var("PI_CODING_AGENT_DIR")
.ok()
.filter(|dir| !dir.trim().is_empty())
else {
return Ok(None);
};
let dir = dir.trim();
if !dir.starts_with('~') {
return Ok(Some(PathBuf::from(dir)));
}
let home = crate::config::home_dir().context("no home directory")?;
Ok(Some(common::expand_tilde(dir, &home)))
}
fn pi_agent_dir() -> anyhow::Result<PathBuf> {
if let Some(dir) = configured_pi_agent_dir()? {
return Ok(dir);
}
Ok(crate::config::home_dir()
.context("no home directory")?
.join(".pi")
.join("agent"))
}
fn write_pi_config(
model: &str,
reasons: bool,
vision: bool,
context_window: Option<u64>,
) -> anyhow::Result<()> {
let dir = pi_agent_dir()?;
let entry = pi_model_entry(model, reasons, vision, context_window);
common::write_json_merged(&dir.join("models.json"), "pi", |existing| {
pi_models_merged(existing, &server(), &entry)
})?;
common::write_json_merged(&dir.join("settings.json"), "pi", |existing| {
pi_settings_merged(existing, model)
})
}
fn pi_model_entry(
model: &str,
reasons: bool,
vision: bool,
context_window: Option<u64>,
) -> serde_json::Value {
let input: &[&str] = if vision {
&["text", "image"]
} else {
&["text"]
};
let mut entry = serde_json::json!({
"id": model,
"name": model,
"input": input,
});
if reasons {
entry["reasoning"] = serde_json::json!(true);
}
if let Some(context) = context_window {
entry["contextWindow"] = serde_json::json!(context);
}
entry
}
fn provider_models_merged(
existing: &serde_json::Value,
provider_name: &str,
entry: &serde_json::Value,
preserve_existing_model_fields: bool,
configure: impl FnOnce(&mut serde_json::Map<String, serde_json::Value>),
) -> serde_json::Value {
let mut root = existing.clone();
let Some(root_map) = root.as_object_mut() else {
return serde_json::json!({});
};
let provider = common::object_under(common::object_under(root_map, "providers"), provider_name);
let old_models = provider
.get("models")
.and_then(serde_json::Value::as_array)
.cloned()
.unwrap_or_default();
let mut replaced = false;
let mut models = Vec::with_capacity(old_models.len() + 1);
for old in old_models {
if old.get("id") != entry.get("id") {
models.push(old);
continue;
}
if replaced {
continue;
}
let mut merged = if preserve_existing_model_fields {
old
} else {
serde_json::json!({})
};
if let (Some(merged), Some(update)) = (merged.as_object_mut(), entry.as_object()) {
merged.extend(update.clone());
} else {
merged = entry.clone();
}
models.push(merged);
replaced = true;
}
if !replaced {
models.push(entry.clone());
}
configure(provider);
provider.insert("models".into(), serde_json::json!(models));
root
}
fn pi_models_merged(
existing: &serde_json::Value,
server: &str,
entry: &serde_json::Value,
) -> serde_json::Value {
provider_models_merged(existing, PI_PROVIDER, entry, false, |provider| {
provider.insert("baseUrl".into(), serde_json::json!(format!("{server}/v1")));
provider
.entry("api")
.or_insert_with(|| serde_json::json!("openai-completions"));
provider
.entry("apiKey")
.or_insert_with(|| serde_json::json!("llmman"));
})
}
fn pi_settings_merged(existing: &serde_json::Value, model: &str) -> serde_json::Value {
let mut root = existing.clone();
root["defaultProvider"] = serde_json::json!(PI_PROVIDER);
root["defaultModel"] = serde_json::json!(model);
root
}
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 launch_aider(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
let base_url = format!("{}/v1", server());
let mut args: Vec<String> = Vec::new();
if !model.is_empty() {
args.extend(["--model".to_string(), format!("openai/{model}")]);
}
args.extend(["--openai-api-base".to_string(), base_url.clone()]);
args.extend_from_slice(extra_args);
exec_with_env(
&PathBuf::from("aider"),
&args,
&[
("OPENAI_API_KEY", api_key),
("OPENAI_BASE_URL", base_url.as_str()),
],
)
}
fn launch_gemini(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin = find_on_path("gemini").ok_or_else(|| anyhow::anyhow!("gemini is not installed"))?;
let mut args: Vec<String> = Vec::new();
if !model.is_empty() {
args.extend(["--model".to_string(), model.to_string()]);
}
args.extend_from_slice(extra_args);
let base_url = format!("{}/v1", server());
exec_with_env(
&bin,
&args,
&[
("GEMINI_BASE_URL", base_url.as_str()),
("GEMINI_API_KEY", api_key),
],
)
}
fn launch_simple(binary: &str, _model: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin = find_on_path(binary).ok_or_else(|| anyhow::anyhow!("{binary} is not installed"))?;
let server = server();
exec_with_env(&bin, extra_args, &[("OLLAMA_HOST", server.as_str())])
}
fn launch_hermes(model: &str, vision: bool, extra_args: &[String]) -> anyhow::Result<()> {
let bin = find_on_path("hermes").ok_or_else(|| anyhow::anyhow!("hermes is not installed"))?;
write_hermes_config(if model.is_empty() { "default" } else { model }, vision)?;
exec_with_env(&bin, extra_args, &[])
}
fn hermes_home() -> anyhow::Result<PathBuf> {
if let Ok(dir) = std::env::var("HERMES_HOME") {
if !dir.trim().is_empty() {
return Ok(PathBuf::from(dir));
}
}
if cfg!(windows) {
if let Ok(local_app_data) = std::env::var("LOCALAPPDATA") {
if !local_app_data.trim().is_empty() {
return Ok(PathBuf::from(local_app_data).join("hermes"));
}
}
let home = dirs::home_dir().context("no home directory")?;
return Ok(home.join("AppData").join("Local").join("hermes"));
}
let home = dirs::home_dir().context("no home directory")?;
Ok(home.join(".hermes"))
}
fn write_hermes_config(model: &str, vision: bool) -> anyhow::Result<()> {
let config_dir = hermes_home()?;
std::fs::create_dir_all(&config_dir)?;
let config_path = config_dir.join("config.yaml");
let existing = std::fs::read_to_string(&config_path).unwrap_or_default();
let preserved =
strip_yaml_top_level_key(&strip_yaml_top_level_key(&existing, "model"), "providers");
let ours = hermes_config_blocks(model, &format!("{}/v1", server()), vision);
std::fs::write(&config_path, format!("{preserved}{ours}"))?;
Ok(())
}
fn hermes_config_blocks(model: &str, base_url: &str, vision: bool) -> String {
let model = common::yaml_quote(model);
let base_url = common::yaml_quote(base_url);
let vision = if vision {
" supports_vision: true\n"
} else {
""
};
format!(
"model:\n provider: llmman\n default: {model}\n base_url: {base_url}\n api_key: llmman\n{vision}\
providers:\n llmman:\n name: llmman\n api: {base_url}\n default_model: {model}\n models:\n - {model}\n"
)
}
fn strip_yaml_top_level_key(existing: &str, key: &str) -> String {
let header = format!("{key}:");
let mut out = String::new();
let mut skipping = false;
for line in existing.lines() {
let trimmed = line.trim_start();
if trimmed.is_empty() || trimmed.starts_with('#') {
if !skipping {
out.push_str(line);
out.push('\n');
}
continue;
}
if !line.starts_with([' ', '\t']) {
skipping = line.trim_end() == header;
if skipping {
continue;
}
} else if skipping {
continue;
}
out.push_str(line);
out.push('\n');
}
out
}
fn launch_qwen(
model: &str,
api_key: &str,
vision: bool,
effort: Option<&Effort>,
extra_args: &[String],
) -> anyhow::Result<()> {
let bin = find_qwen().ok_or_else(|| anyhow::anyhow!("qwen is not installed"))?;
let (model, vision) = qwen_model_and_vision(model, vision, extra_args);
write_qwen_settings(model, vision, effort)?;
let base_url = format!("{}/v1", server());
let mut env = vec![
("OPENAI_BASE_URL", base_url.as_str()),
("OPENAI_API_KEY", api_key),
(QWEN_ENV_KEY, api_key),
("OPENAI_MODEL", model),
];
let path = path_with_dir_prepended(bin.parent(), &std::env::var_os("PATH").unwrap_or_default())
.map(|p| p.to_string_lossy().into_owned());
if let Some(path) = &path {
env.push(("PATH", path.as_str()));
}
exec_with_env(&bin, &qwen_args(model, extra_args), &env)
}
fn qwen_model_and_vision<'a>(
model: &'a str,
vision: bool,
extra_args: &'a [String],
) -> (&'a str, bool) {
let forwarded = common::forwarded_model(extra_args);
let same = forwarded.is_none_or(|f| {
crate::shortnames::resolve_ollama_api(f).is_ok_and(|resolved| resolved == model)
});
(forwarded.unwrap_or(model), vision && same)
}
fn path_with_dir_prepended(
dir: Option<&Path>,
path_var: &std::ffi::OsStr,
) -> Option<std::ffi::OsString> {
let dir = dir?;
let mut components: Vec<PathBuf> = std::env::split_paths(path_var)
.filter(|d| !d.as_os_str().is_empty())
.collect();
if components.iter().any(|d| d == dir) {
return None;
}
components.insert(0, dir.to_path_buf());
std::env::join_paths(components).ok()
}
fn qwen_args(model: &str, extra_args: &[String]) -> Vec<String> {
let mut args = Vec::with_capacity(extra_args.len() + 4);
if !has_flag(extra_args, "--auth-type", Some("--authType")) {
args.extend(["--auth-type".to_string(), "openai".to_string()]);
}
if !has_flag(extra_args, "--model", Some("-m")) {
args.extend(["--model".to_string(), model.to_string()]);
}
args.extend_from_slice(extra_args);
args
}
fn find_qwen() -> Option<PathBuf> {
find_on_path("qwen").or_else(|| qwen_fallback_paths().into_iter().find(|p| p.is_file()))
}
fn qwen_fallback_paths() -> Vec<PathBuf> {
let home = dirs::home_dir();
let mut paths = Vec::new();
if cfg!(windows) {
let roaming = std::env::var_os("APPDATA")
.filter(|d| !d.is_empty())
.map(PathBuf::from)
.or_else(|| home.as_ref().map(|h| h.join("AppData").join("Roaming")));
let local = std::env::var_os("LOCALAPPDATA")
.filter(|d| !d.is_empty())
.map(PathBuf::from)
.or_else(|| home.as_ref().map(|h| h.join("AppData").join("Local")));
let dirs = [
roaming.as_ref().map(|d| d.join("npm")),
local.as_ref().map(|d| d.join("npm")),
local.as_ref().map(|d| d.join("qwen-code").join("bin")),
local.as_ref().map(|d| d.join("Programs").join("qwen")),
roaming.as_ref().map(|d| d.join("qwen").join("bin")),
];
for dir in dirs.into_iter().flatten() {
paths.extend(
WINDOWS_PATH_EXTS
.iter()
.map(|ext| dir.join(format!("qwen.{ext}"))),
);
}
return paths;
}
if let Some(h) = &home {
paths.push(h.join(".local").join("bin").join("qwen"));
paths.push(h.join(".npm-global").join("bin").join("qwen"));
paths.push(h.join(".cargo").join("bin").join("qwen"));
if cfg!(target_os = "macos") {
paths.push(
h.join("Library")
.join("Application Support")
.join("qwen")
.join("bin")
.join("qwen"),
);
}
paths.extend(nvm_qwen(h));
}
if cfg!(target_os = "macos") {
paths.push(PathBuf::from("/opt/homebrew/bin/qwen"));
} else {
paths.push(PathBuf::from("/home/linuxbrew/.linuxbrew/bin/qwen"));
}
paths.push(PathBuf::from("/usr/local/bin/qwen"));
paths
}
fn nvm_qwen(home: &Path) -> Option<PathBuf> {
std::fs::read_dir(home.join(".nvm").join("versions").join("node"))
.ok()?
.filter_map(|e| e.ok())
.map(|e| e.path().join("bin").join("qwen"))
.find(|p| p.is_file())
}
fn qwen_home() -> anyhow::Result<PathBuf> {
let home = || dirs::home_dir().context("no home directory");
match std::env::var("QWEN_HOME").ok().filter(|d| !d.is_empty()) {
Some(dir) if !dir.starts_with('~') => Ok(PathBuf::from(dir)),
Some(dir) => Ok(common::expand_tilde(&dir, &home()?)),
None => Ok(home()?.join(".qwen")),
}
}
fn write_qwen_settings(model: &str, vision: bool, effort: Option<&Effort>) -> anyhow::Result<()> {
write_qwen_settings_at(
&qwen_home()?,
model,
&format!("{}/v1", server()),
vision,
effort,
)
}
fn write_qwen_settings_at(
dir: &Path,
model: &str,
base_url: &str,
vision: bool,
effort: Option<&Effort>,
) -> anyhow::Result<()> {
common::write_json_merged(&dir.join("settings.json"), "qwen", |existing| {
qwen_settings_merged(existing, model, base_url, vision, effort)
})
}
const QWEN_ENV_KEY: &str = "LLMMAN_API_KEY";
fn qwen_settings_merged(
existing: &serde_json::Value,
model: &str,
base_url: &str,
vision: bool,
effort: Option<&Effort>,
) -> serde_json::Value {
let mut doc = existing.as_object().cloned().unwrap_or_default();
let mut ours = serde_json::json!({
"id": model,
"name": format!("{model} (llmman)"),
"baseUrl": base_url,
"envKey": QWEN_ENV_KEY,
});
if vision {
ours["generationConfig"] = serde_json::json!({ "modalities": { "image": true } });
}
if let Some(effort) = effort {
let efforts: Vec<&str> = effort
.levels
.iter()
.copied()
.filter(|l| *l != "none")
.collect();
let mut reasoning = serde_json::json!({
"thinking": true,
"disableField": "reasoning_effort",
"profile": "openai-effort",
"efforts": efforts,
});
ours["generationConfig"]["reasoning"] = match effort.default {
"none" => serde_json::json!(false),
level => {
reasoning["defaultEffort"] = level.into();
serde_json::json!({ "effort": level })
}
};
ours["capabilities"] = serde_json::json!({ "reasoning": reasoning });
}
let openai = common::object_under(&mut doc, "modelProviders")
.entry("openai")
.or_insert_with(|| serde_json::json!([]));
let unwrapped = openai.get("models").is_some_and(|m| m.is_array());
let entries = openai
.as_array()
.or_else(|| openai.get("models").and_then(serde_json::Value::as_array));
let kept = entries.map_or_else(Vec::new, |entries| {
entries
.iter()
.filter(|e| !qwen_entry_is_ours(e, base_url))
.cloned()
.collect()
});
*openai = serde_json::Value::Array(std::iter::once(ours).chain(kept).collect());
if unwrapped {
doc.insert("$version".into(), 4.into());
}
let auth = common::object_under(common::object_under(&mut doc, "security"), "auth");
auth.insert("selectedType".into(), "openai".into());
auth.insert("baseUrl".into(), base_url.into());
let model_cfg = common::object_under(&mut doc, "model");
model_cfg.insert("name".into(), model.into());
model_cfg.insert("baseUrl".into(), base_url.into());
if effort.is_some() {
model_cfg.remove("reasoningEffort");
}
serde_json::Value::Object(doc)
}
fn qwen_entry_is_ours(entry: &serde_json::Value, base_url: &str) -> bool {
let field = |k: &str| entry.get(k).and_then(serde_json::Value::as_str);
field("envKey") == Some(QWEN_ENV_KEY)
&& field("baseUrl")
.is_some_and(|u| u.trim_end_matches('/') == base_url.trim_end_matches('/'))
}
fn launch_cline(model: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin = find_on_path("cline").ok_or_else(|| anyhow::anyhow!("cline is not installed"))?;
write_cline_settings(model)?;
exec_with_env(&bin, extra_args, &[])
}
fn cline_dir() -> anyhow::Result<PathBuf> {
resolve_cline_dir(env_dir("CLINE_DIR"), node_user_profile(), || {
dirs::home_dir().context("no home directory")
})
}
fn node_user_profile() -> Option<PathBuf> {
cfg!(windows).then(|| env_dir("USERPROFILE")).flatten()
}
fn resolve_cline_dir(
cline_dir: Option<PathBuf>,
user_profile: Option<PathBuf>,
home: impl FnOnce() -> anyhow::Result<PathBuf>,
) -> anyhow::Result<PathBuf> {
if let Some(dir) = cline_dir {
return Ok(dir);
}
Ok(match user_profile {
Some(profile) => profile,
None => home()?,
}
.join(".cline"))
}
fn cline_data_dir() -> anyhow::Result<PathBuf> {
Ok(cline_dir()?.join("data"))
}
fn write_cline_settings(model: &str) -> anyhow::Result<()> {
let server = server();
let now = chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
write_cline_settings_at(&cline_data_dir()?, model, &server, &now)
}
const CLINE_RESPONSE_START_TIMEOUT_MS: u64 = 30 * 60 * 1000;
fn read_cline_json(path: &Path) -> anyhow::Result<(Option<Vec<u8>>, serde_json::Value)> {
let raw = match std::fs::read(path) {
Ok(raw) => Some(raw),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => None,
Err(error) => return Err(error).with_context(|| format!("read {}", path.display())),
};
let document = match raw.as_deref().map(|bytes| String::from_utf8_lossy(bytes)) {
None => serde_json::json!({}),
Some(text) if text.trim().is_empty() => serde_json::json!({}),
Some(text) => serde_json::from_str(&text)
.with_context(|| format!("parse {} as JSON", path.display()))?,
};
anyhow::ensure!(
document.is_object(),
"{} is not a JSON object",
path.display()
);
Ok((raw, document))
}
fn write_cline_json(
path: &Path,
raw: Option<&[u8]>,
before: &serde_json::Value,
after: &serde_json::Value,
) -> anyhow::Result<()> {
if before == after {
return Ok(());
}
let parent = path
.parent()
.context("Cline settings path has no directory")?;
std::fs::create_dir_all(parent).with_context(|| format!("create {}", parent.display()))?;
if let Some(raw) = raw {
let backup = path.with_extension("json.bak");
std::fs::write(&backup, raw)
.with_context(|| format!("back up {} to {}", path.display(), backup.display()))?;
}
let mut contents = serde_json::to_vec_pretty(after).context("serialize Cline settings")?;
contents.push(b'\n');
crate::fsutil::write_atomic(path, &contents)
.with_context(|| format!("write {}", path.display()))
}
fn write_cline_settings_at(
data_dir: &Path,
model: &str,
server: &str,
now: &str,
) -> anyhow::Result<()> {
let providers_path = data_dir.join("settings/providers.json");
let (providers_raw, mut providers_document) = read_cline_json(&providers_path)?;
let providers_before = providers_document.clone();
let base_url = format!("{server}/v1");
let route_changed = providers_document
.pointer("/providers/ollama/settings/model")
.and_then(serde_json::Value::as_str)
!= Some(model)
|| providers_document
.pointer("/providers/ollama/settings/baseUrl")
.and_then(serde_json::Value::as_str)
!= Some(base_url.as_str())
|| providers_document
.pointer("/providers/ollama/settings/timeout")
.is_none();
let root = providers_document
.as_object_mut()
.expect("read_cline_json returns an object");
root.insert("version".to_string(), serde_json::json!(1));
root.insert("lastUsedProvider".to_string(), serde_json::json!("ollama"));
let providers = root
.entry("providers")
.or_insert_with(|| serde_json::json!({}))
.as_object_mut()
.context("Cline providers is not a JSON object")?;
let ollama = providers
.entry("ollama")
.or_insert_with(|| serde_json::json!({}))
.as_object_mut()
.context("Cline providers.ollama is not a JSON object")?;
let settings = ollama
.entry("settings")
.or_insert_with(|| serde_json::json!({}))
.as_object_mut()
.context("Cline providers.ollama.settings is not a JSON object")?;
settings.insert("provider".to_string(), serde_json::json!("ollama"));
settings.insert("model".to_string(), serde_json::json!(model));
settings.insert("baseUrl".to_string(), serde_json::json!(base_url));
settings
.entry("timeout")
.or_insert_with(|| serde_json::json!(CLINE_RESPONSE_START_TIMEOUT_MS));
settings.remove("apiKey");
ollama.insert("tokenSource".to_string(), serde_json::json!("manual"));
if route_changed {
ollama.insert("updatedAt".to_string(), serde_json::json!(now));
}
write_cline_json(
&providers_path,
providers_raw.as_deref(),
&providers_before,
&providers_document,
)?;
let global_state_path = data_dir.join("globalState.json");
let (global_raw, mut global_document) = read_cline_json(&global_state_path)?;
let global_before = global_document.clone();
let global = global_document
.as_object_mut()
.expect("read_cline_json returns an object");
for key in [
"ollamaBaseUrl",
"actModeOllamaBaseUrl",
"planModeOllamaBaseUrl",
] {
global.insert(key.to_string(), serde_json::json!(server));
}
for key in ["actModeApiProvider", "planModeApiProvider"] {
global.insert(key.to_string(), serde_json::json!("ollama"));
}
for key in ["actModeOllamaModelId", "planModeOllamaModelId"] {
global.insert(key.to_string(), serde_json::json!(model));
}
global.insert("welcomeViewCompleted".to_string(), serde_json::json!(true));
write_cline_json(
&global_state_path,
global_raw.as_deref(),
&global_before,
&global_document,
)
}
const GROK_API_KEY_ENV: &str = "LLMMAN_GROK_API_KEY";
fn launch_grok(
model: &str,
api_key: &str,
effort: Option<&Effort>,
extra_args: &[String],
) -> anyhow::Result<()> {
let bin = find_grok().ok_or_else(|| anyhow::anyhow!("grok is not installed"))?;
let effective_model = common::forwarded_model(extra_args).unwrap_or(model);
let base_url = format!("{}/v1", server());
let models_url = format!("{base_url}/models");
let home = grok_home()?.join("llmman");
let efforts = effort.map_or(&[][..], |e| &e.levels);
write_grok_config(&home, effective_model, &base_url, efforts)?;
let home = home.to_string_lossy().into_owned();
let args = grok_args(model, extra_args);
exec_with_env(
&bin,
&args,
&grok_env(effective_model, api_key, &base_url, &models_url, &home),
)
}
fn grok_env<'a>(
model: &'a str,
api_key: &'a str,
base_url: &'a str,
models_url: &'a str,
home: &'a str,
) -> Vec<(&'a str, &'a str)> {
vec![
("GROK_HOME", home),
("GROK_MODELS_BASE_URL", base_url),
("GROK_MODELS_LIST_URL", models_url),
("GROK_DEFAULT_MODEL", model),
("GROK_WEB_SEARCH_MODEL", model),
("GROK_SESSION_SUMMARY_MODEL", model),
("GROK_IMAGE_DESCRIPTION_MODEL", model),
("GROK_PROMPT_SUGGESTIONS_MODEL", model),
(GROK_API_KEY_ENV, api_key),
("XAI_API_KEY", api_key),
]
}
fn grok_home() -> anyhow::Result<PathBuf> {
if let Some(path) = env_dir("GROK_HOME") {
return Ok(path);
}
Ok(dirs::home_dir().context("no home directory")?.join(".grok"))
}
fn write_grok_config(
home: &Path,
model: &str,
base_url: &str,
efforts: &[&str],
) -> anyhow::Result<()> {
let path = home.join("config.toml");
std::fs::create_dir_all(home).with_context(|| format!("create {}", home.display()))?;
let contents = grok_config_document(model, base_url, efforts);
crate::fsutil::write_atomic(&path, contents.as_bytes())
.with_context(|| format!("write {}", path.display()))
}
fn grok_config_document(model: &str, base_url: &str, efforts: &[&str]) -> String {
let mut entry = toml_edit::Table::new();
entry["model"] = toml_edit::value(model);
entry["base_url"] = toml_edit::value(base_url);
entry["env_key"] = toml_edit::value(GROK_API_KEY_ENV);
entry["api_backend"] = toml_edit::value("chat_completions");
if !efforts.is_empty() {
entry["reasoning_efforts"] =
toml_edit::value(efforts.iter().copied().collect::<toml_edit::Array>());
}
let mut models = toml_edit::Table::new();
models.insert(model, toml_edit::Item::Table(entry));
let mut document = toml_edit::DocumentMut::new();
document.insert("model", toml_edit::Item::Table(models));
document.to_string()
}
fn grok_args(model: &str, extra_args: &[String]) -> Vec<String> {
let mut args = Vec::with_capacity(extra_args.len() + 2);
if !has_flag(extra_args, "--model", Some("-m")) {
args.extend(["--model".to_string(), model.to_string()]);
}
args.extend_from_slice(extra_args);
args
}
fn find_grok() -> Option<PathBuf> {
find_on_path("grok").or_else(|| grok_fallback(&dirs::home_dir()?))
}
fn grok_fallback(home: &Path) -> Option<PathBuf> {
let binary = if cfg!(windows) { "grok.exe" } else { "grok" };
let candidate = home.join(".grok").join("bin").join(binary);
candidate.is_file().then_some(candidate)
}
const DSH_API_KEY_ENV: &str = "LLMMAN_API_KEY";
fn launch_dsh(
model: &str,
api_key: &str,
vision: bool,
effort: Option<&Effort>,
extra_args: &[String],
) -> anyhow::Result<()> {
let launcher = dsh_launcher(extra_args);
if has_flag(launcher.args, "--patch", None) {
anyhow::bail!("llmman launch dsh manages --patch itself; pass other dsh flags after --");
}
if let Some(command) = launcher.command {
anyhow::bail!(
"dsh's `{command}` command cannot be combined with the --patch llmman passes it.\n\
Select a profile with `--profile {}` instead, or omit it for the default.",
if command == "web" { "web" } else { "<name>" }
);
}
let (bin, prefix) = find_dsh().ok_or_else(|| {
anyhow::anyhow!("dsh is not installed, and there is no npx on PATH to run it with")
})?;
let dir = dsh_config_dir()?;
let settings_path = dir.join("settings.yaml");
write_dsh_settings(&settings_path, model, vision, effort)?;
let patch_path = dir.join("llmman.cordis.yml");
write_dsh_patch(&patch_path, &settings_path)?;
let mut args = prefix;
if !args.is_empty() {
eprintln!("[llmman] dsh is not installed; running {DSH_NPM_PACKAGE} with npx");
}
args.extend(dsh_args(&patch_path, extra_args));
exec_with_env(&bin, &args, &[(DSH_API_KEY_ENV, api_key)])
}
const DSH_NPM_PACKAGE: &str = "@deepseek-ai/dsh@latest";
fn find_dsh() -> Option<(PathBuf, Vec<String>)> {
dsh_command(find_on_path("dsh"), || find_on_path("npx"))
}
fn dsh_command(
dsh: Option<PathBuf>,
npx: impl FnOnce() -> Option<PathBuf>,
) -> Option<(PathBuf, Vec<String>)> {
match dsh {
Some(bin) => Some((bin, Vec::new())),
None => Some((npx()?, vec!["--yes".into(), DSH_NPM_PACKAGE.into()])),
}
}
fn dsh_launcher(extra_args: &[String]) -> DshLauncher<'_> {
let mut end = 0;
let mut command = None;
while let Some(arg) = extra_args.get(end) {
if arg == "--" {
break;
}
end += match arg.as_str() {
"--profile" | "--patch" => 2,
found @ ("web" | "plugin") => {
command = command.or(Some(found));
1
}
_ if arg.starts_with('-') => 1,
_ => break,
};
}
DshLauncher {
args: &extra_args[..end.min(extra_args.len())],
command,
}
}
struct DshLauncher<'a> {
args: &'a [String],
command: Option<&'a str>,
}
fn dsh_args(patch_path: &Path, extra_args: &[String]) -> Vec<String> {
let mut args = Vec::new();
if !has_flag(dsh_launcher(extra_args).args, "--profile", None) {
args.push("web".to_string());
}
args.push("--patch".to_string());
args.push(patch_path.to_string_lossy().into_owned());
args.extend_from_slice(extra_args);
args
}
fn dsh_config_dir() -> anyhow::Result<PathBuf> {
let conf = crate::config::user_path().context("no home directory")?;
let dir = conf.parent().context("llmman.conf has no directory")?;
Ok(dir.join("launch").join("dsh"))
}
fn write_dsh_settings(
path: &Path,
model: &str,
vision: bool,
effort: Option<&Effort>,
) -> anyhow::Result<()> {
let quoted_model = common::yaml_quote(model);
let base_url = common::yaml_quote(&format!("{}/v1", server()));
let input = if vision { "[text, image]" } else { "[text]" };
let (reasoning, efforts) = effort.map_or_else(Default::default, |e| {
let map: Vec<String> = (e.levels.iter())
.map(|&l| format!("{l}: {}", if l == "off" { "none" } else { l }))
.collect();
(
format!(" reasoning: {}\n", e.default),
format!(" reasoningEfforts: {{ {} }}\n", map.join(", ")),
)
});
let contents = format!(
"# Written by `llmman launch dsh`; edits are overwritten.\n\
agent-default-model:\n provider: llmman\n model: {quoted_model}\n\
llm-pi-ai:\n providers:\n llmman:\n displayName: llmman\n \
apiKeyEnv: {DSH_API_KEY_ENV}\n api: openai-completions\n baseURL: {base_url}\n\
{reasoning} \
models:\n - id: {quoted_model}\n name: {quoted_model}\n input: {input}\n\
{efforts}"
);
write_dsh_file(path, &contents)
}
fn write_dsh_patch(path: &Path, settings_path: &Path) -> anyhow::Result<()> {
write_dsh_file(path, &dsh_patch_document(settings_path))
}
fn dsh_patch_document(settings_path: &Path) -> String {
let quoted_settings_path = common::yaml_quote(&settings_path.to_string_lossy());
format!(
"# Written by `llmman launch dsh`; edits are overwritten.\n\
- id: settings\n config:\n path: {quoted_settings_path}\n"
)
}
fn write_dsh_file(path: &Path, contents: &str) -> anyhow::Result<()> {
if let Some(dir) = path.parent() {
std::fs::create_dir_all(dir).with_context(|| format!("create {}", dir.display()))?;
}
crate::fsutil::write_atomic(path, contents.as_bytes())
.with_context(|| format!("write {}", path.display()))
}
const DOCKER_AGENT_API_KEY_ENV: &str = "LLMMAN_API_KEY";
const DOCKER_AGENT_MODEL_NAME: &str = "llmman";
fn launch_docker_agent(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
check_docker_agent_args(extra_args)?;
let bin = find_docker_agent().ok_or_else(|| {
anyhow::anyhow!(
"docker-agent is not installed\n\n\
llmman looks for it on PATH and in ~/.docker/cli-plugins, where Docker Desktop \
and `brew install docker-agent` put it.\n\
Releases: https://github.com/docker/docker-agent/releases"
)
})?;
let path = docker_agent_agent_file(&docker_agent_config_dir()?, model);
write_docker_agent_file(&path, model, &format!("{}/v1", server()))?;
let args = docker_agent_args(&path, extra_args);
exec_with_env(&bin, &args, &[(DOCKER_AGENT_API_KEY_ENV, api_key)])
}
fn check_docker_agent_args(extra_args: &[String]) -> anyhow::Result<()> {
let flags = &extra_args[..extra_args
.iter()
.position(|arg| arg == "--")
.unwrap_or(extra_args.len())];
if has_flag(flags, "--model", None) {
anyhow::bail!(
"docker-agent's --model would replace the endpoint llmman configured and send the \
request to api.openai.com; select the model with `llmman launch docker-agent \
--model <model>` instead"
);
}
if let Some(file) = docker_agent_config_argument(extra_args) {
anyhow::bail!(docker_agent_own_agent_file_error(file));
}
Ok(())
}
fn docker_agent_own_agent_file_error(file: &str) -> String {
format!(
"llmman launch docker-agent passes its own agent file, so `{file}` would be read as a \
message rather than an agent.\n\
To run your own agent against this daemon, point its model at llmman and run \
docker-agent directly:\n \
models:\n {DOCKER_AGENT_MODEL_NAME}:\n provider: openai\n \
model: <model>\n base_url: {}/v1\n \
token_key: {DOCKER_AGENT_API_KEY_ENV}\n \
agents:\n root:\n model: {DOCKER_AGENT_MODEL_NAME}",
daemon::server()
)
}
fn docker_agent_config_dir() -> anyhow::Result<PathBuf> {
let conf = crate::config::user_path().context("no home directory")?;
let dir = conf.parent().context("llmman.conf has no directory")?;
Ok(dir.join("launch").join("docker-agent"))
}
fn docker_agent_agent_file(dir: &Path, model: &str) -> PathBuf {
dir.join(format!("agent-{}.yaml", docker_agent_file_stem(model)))
}
const DOCKER_AGENT_NAME_MAX: usize = 80;
fn docker_agent_file_stem(model: &str) -> String {
use sha2::Digest as _;
let safe: String = model
.chars()
.map(|c| {
if c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-') {
c
} else {
'-'
}
})
.take(DOCKER_AGENT_NAME_MAX)
.collect();
let digest = hex::encode(sha2::Sha256::digest(model.as_bytes()));
format!("{safe}-{}", &digest[..8])
}
fn write_docker_agent_file(path: &Path, model: &str, base_url: &str) -> anyhow::Result<()> {
if let Some(dir) = path.parent() {
std::fs::create_dir_all(dir).with_context(|| format!("create {}", dir.display()))?;
}
let contents = docker_agent_document(model, base_url);
crate::fsutil::write_atomic(path, contents.as_bytes())
.with_context(|| format!("write {}", path.display()))
}
fn docker_agent_document(model: &str, base_url: &str) -> String {
let quoted_model = common::yaml_quote(model);
let quoted_base_url = common::yaml_quote(base_url);
format!(
"# Written by `llmman launch docker-agent`; edits are overwritten.\n\
version: \"2\"\n\
models:\n {DOCKER_AGENT_MODEL_NAME}:\n provider: openai\n model: {quoted_model}\n \
base_url: {quoted_base_url}\n token_key: {DOCKER_AGENT_API_KEY_ENV}\n\
agents:\n root:\n model: {DOCKER_AGENT_MODEL_NAME}\n \
description: The agent `llmman launch docker-agent` runs.\n \
instruction: You are a helpful AI assistant with access to the shell and \
the filesystem.\n \
toolsets:\n - type: shell\n - type: filesystem\n"
)
}
fn docker_agent_args(path: &Path, extra_args: &[String]) -> Vec<String> {
let mut args = vec!["run".to_string(), path.to_string_lossy().into_owned()];
args.extend_from_slice(extra_args);
args
}
fn docker_agent_config_argument(extra_args: &[String]) -> Option<&String> {
docker_agent_config_argument_with(extra_args, |path| Path::new(path).is_file())
}
fn docker_agent_config_argument_with(
extra_args: &[String],
exists: impl Fn(&str) -> bool,
) -> Option<&String> {
const EXTENSIONS: &[&str] = &[".yaml", ".yml", ".hcl"];
let first = extra_args.first()?;
if first.starts_with('-') {
return None;
}
let lowered = first.to_lowercase();
let named_like_one = EXTENSIONS.iter().any(|ext| lowered.ends_with(ext));
(named_like_one && exists(first)).then_some(first)
}
fn find_docker_agent() -> Option<PathBuf> {
find_on_path("docker-agent").or_else(|| docker_agent_fallback(&dirs::home_dir()?))
}
fn docker_agent_fallback(home: &Path) -> Option<PathBuf> {
let binary = if cfg!(windows) {
"docker-agent.exe"
} else {
"docker-agent"
};
let candidate = home.join(".docker").join("cli-plugins").join(binary);
candidate.is_file().then_some(candidate)
}
fn exec_with_env(bin: &Path, args: &[String], extra_env: &[(&str, &str)]) -> anyhow::Result<()> {
std::process::exit(run_with_env(bin, args, extra_env)?);
}
fn run_with_env(bin: &Path, args: &[String], extra_env: &[(&str, &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);
}
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);
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 agy_is_listed_as_an_integration() {
let agy = INTEGRATIONS.iter().find(|i| i.name == "agy").unwrap();
assert_eq!(agy.binary, "agy");
}
#[test]
fn every_provider_unsupported_integration_is_a_real_one() {
for (id, why) in PROVIDER_UNSUPPORTED {
assert!(
INTEGRATIONS.iter().any(|i| i.name == *id) || *id == "copilot-cli",
"{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_agent_dir().unwrap());
covers("omp", omp_agent_dir().unwrap());
covers("cline", cline_data_dir().unwrap());
covers("agy", agy::agy_settings_dir().unwrap());
covers("hermes", hermes_home().unwrap());
covers("qwen", qwen_home().unwrap());
covers("dsh", dsh_config_dir().unwrap());
covers("grok", grok_home().unwrap().join("llmman"));
covers("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!(
INTEGRATIONS.iter().any(|i| i.name == *id),
"{id} is not an integration"
);
assert!(check_model_flag(id, None, None, &none).is_err());
assert!(check_model_flag(id, Some(" "), None, &none).is_err());
assert!(check_model_flag(&id.to_uppercase(), None, None, &none).is_err());
let err = check_model_flag(id, None, Some("openrouter"), &none).unwrap_err();
assert!(
err.to_string().contains("--provider openrouter --model"),
"{err}"
);
assert!(check_model_flag(id, Some("m"), None, &none).is_ok());
let forwarded = vec!["--model".to_string(), "theirs".to_string()];
assert!(check_model_flag(id, Some("m"), None, &forwarded).is_ok());
}
assert!(check_model_flag("claude", None, None, &none).is_ok());
for id in MODEL_FLAG_FORWARDED {
assert!(MODEL_REQUIRED.contains(id), "{id} is not model-required");
}
assert!(!MODEL_FLAG_FORWARDED.contains(&"dsh"));
}
#[test]
fn omp_is_listed_and_selects_the_model_through_ollama() {
let omp = INTEGRATIONS.iter().find(|i| i.name == "omp").unwrap();
assert_eq!(omp.binary, "omp");
assert!(MODEL_REQUIRED.contains(&"omp"));
assert!(MODEL_FLAG_FORWARDED.contains(&"omp"));
assert_eq!(
omp_args("docker.io/ai/qwen3.5:0.8b", &[]),
vec!["--model", "ollama/docker.io/ai/qwen3.5:0.8b"]
);
let existing = serde_json::json!({
"providers": {
"other": { "baseUrl": "https://example.com" },
"ollama": {
"auth": "none",
"headers": { "X-Custom": "kept" },
"models": [
{
"id": "docker.io/ai/qwen3.5:0.8b",
"name": "User name",
"input": ["text", "image"],
"maxTokens": 4096
},
{ "id": "old", "name": "Old" }
]
}
}
});
let entry = serde_json::json!({
"id": "docker.io/ai/qwen3.5:0.8b",
"name": "docker.io/ai/qwen3.5:0.8b",
"input": ["text"]
});
let merged = omp_models_merged(&existing, "http://127.0.0.1:17434", &entry);
let provider = &merged["providers"]["ollama"];
assert_eq!(provider["baseUrl"], "http://127.0.0.1:17434/v1");
assert_eq!(provider["api"], "openai-responses");
assert!(provider.get("auth").is_none());
assert_eq!(provider["apiKey"], providers::PLACEHOLDER_API_KEY);
assert_eq!(provider["authHeader"], true);
assert_eq!(provider["discovery"]["type"], "ollama");
assert_eq!(provider["headers"]["X-Custom"], "kept");
assert_eq!(provider["models"][0]["name"], entry["name"]);
assert_eq!(provider["models"][0]["input"], entry["input"]);
assert_eq!(provider["models"][0]["maxTokens"], 4096);
assert_eq!(provider["models"][1]["id"], "old");
assert_eq!(
merged["providers"]["other"]["baseUrl"],
"https://example.com"
);
let config = omp_config_merged(&serde_json::json!({
"setupVersion": OMP_SETUP_VERSION + 3,
"theme": "dark"
}));
assert_eq!(config["setupVersion"], OMP_SETUP_VERSION + 3);
assert_eq!(config["theme"], "dark");
}
#[test]
fn omp_model_argument_after_separator_wins_without_a_duplicate() {
let strings = |values: &[&str]| values.iter().map(|s| (*s).to_string()).collect::<Vec<_>>();
for forwarded in [
strings(&["--model", "openrouter/anthropic/claude-sonnet-4"]),
strings(&["-m", "ollama/other"]),
strings(&["--model=ollama/other"]),
strings(&["-m=ollama/other"]),
] {
assert_eq!(omp_args("local", &forwarded), forwarded);
}
assert_eq!(
omp_args("local", &strings(&["-p", "ping"])),
strings(&["--model", "ollama/local", "-p", "ping"])
);
}
#[test]
fn omp_fallback_paths_cover_bun_and_local_bin() {
let paths = omp_fallback_paths();
let binary = if cfg!(windows) { "omp.exe" } else { "omp" };
assert!(paths
.iter()
.any(|path| path.ends_with(Path::new(".bun").join("bin").join(binary))));
assert!(paths
.iter()
.any(|path| path.ends_with(Path::new(".local").join("bin").join(binary))));
}
#[test]
fn omp_config_is_created_for_a_fresh_home_and_round_trips() {
let dir = std::env::temp_dir().join(format!(
"llmman-omp-models-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let models_path = dir.join("models.yml");
write_omp_config_in_dir(
&dir,
"docker.io/ai/qwen3.5:0.8b",
true,
true,
Some(32_768),
"http://127.0.0.1:17434",
)
.unwrap();
let parsed: serde_json::Value =
yaml_serde::from_str(&std::fs::read_to_string(&models_path).unwrap()).unwrap();
let provider = &parsed["providers"]["ollama"];
assert_eq!(provider["baseUrl"], "http://127.0.0.1:17434/v1");
assert_eq!(provider["models"][0]["id"], "docker.io/ai/qwen3.5:0.8b");
assert_eq!(provider["models"][0]["name"], "docker.io/ai/qwen3.5:0.8b");
assert_eq!(provider["models"][0]["reasoning"], true);
assert_eq!(
provider["models"][0]["input"],
serde_json::json!(["text", "image"])
);
assert_eq!(provider["models"][0]["contextWindow"], 32_768);
let config: serde_json::Value =
yaml_serde::from_str(&std::fs::read_to_string(dir.join("config.yml")).unwrap())
.unwrap();
assert_eq!(config["setupVersion"], OMP_SETUP_VERSION);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn omp_models_yml_backs_up_the_exact_commented_file_before_rewriting() {
let dir = std::env::temp_dir().join(format!(
"llmman-omp-models-backup-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("models.yml");
let config_path = dir.join("config.yml");
let original = r#"# my own notes, do not delete
providers:
openai:
apiKey: sk-mine
defaults:
temperature: 0.2 # tuned by hand
"#;
std::fs::write(&path, original).unwrap();
let config_original = "# keep this too\ntheme: dark\n";
std::fs::write(&config_path, config_original).unwrap();
write_omp_config_in_dir(
&dir,
"docker.io/ai/qwen3.5:0.8b",
false,
false,
None,
"http://127.0.0.1:17434",
)
.unwrap();
write_omp_config_in_dir(
&dir,
"docker.io/ai/qwen3.5:0.8b",
false,
false,
Some(4096),
"http://127.0.0.1:17434",
)
.unwrap();
assert_eq!(
std::fs::read_to_string(path.with_extension("yml.bak")).unwrap(),
original
);
let mut hand_edited = std::fs::read_to_string(&path).unwrap();
hand_edited.push_str("# added after the first launch\n");
std::fs::write(&path, &hand_edited).unwrap();
write_omp_config_in_dir(
&dir,
"docker.io/ai/qwen3.5:0.8b",
false,
false,
Some(8192),
"http://127.0.0.1:17434",
)
.unwrap();
assert_eq!(
std::fs::read_to_string(path.with_extension("yml.bak")).unwrap(),
hand_edited
);
let parsed: serde_json::Value =
yaml_serde::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
assert_eq!(parsed["providers"]["openai"]["apiKey"], "sk-mine");
assert_eq!(parsed["defaults"]["temperature"], 0.2);
assert_eq!(
parsed["providers"]["ollama"]["models"][0]["id"],
"docker.io/ai/qwen3.5:0.8b"
);
assert_eq!(
std::fs::read_to_string(config_path.with_extension("yml.bak")).unwrap(),
config_original
);
let config: serde_json::Value =
yaml_serde::from_str(&std::fs::read_to_string(config_path).unwrap()).unwrap();
assert_eq!(config["theme"], "dark");
assert_eq!(config["setupVersion"], OMP_SETUP_VERSION);
std::fs::remove_dir_all(dir).unwrap();
}
#[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 cline_settings_merge_ollama_and_preserve_user_state() {
let root = std::env::temp_dir().join(format!(
"llmman-cline-settings-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let providers_path = root.join("settings/providers.json");
let global_path = root.join("globalState.json");
let model = r#"org/model.\"quoted\""#;
let providers_original = r#"{
"version": 7,
"lastUsedProvider": "anthropic",
"mine": true,
"providers": {
"anthropic": { "settings": { "model": "mine" } },
"ollama": {
"settings": { "provider": "ollama", "model": "old", "baseUrl": "http://old", "apiKey": "delete-me", "keep": 1 },
"updatedAt": "2000-01-01T00:00:00Z",
"other": true
}
}
}"#;
let global_original = r#"{"theme":"mine","welcomeViewCompleted":false}"#;
std::fs::create_dir_all(providers_path.parent().unwrap()).unwrap();
std::fs::write(&providers_path, providers_original).unwrap();
std::fs::write(&global_path, global_original).unwrap();
write_cline_settings_at(
&root,
model,
"http://127.0.0.1:17434",
"2026-09-20T06:00:00Z",
)
.unwrap();
let parsed: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&providers_path).unwrap()).unwrap();
let entry = &parsed["providers"]["ollama"];
assert_eq!(parsed["version"], 1);
assert_eq!(parsed["lastUsedProvider"], "ollama");
assert_eq!(parsed["mine"], true);
assert_eq!(
parsed["providers"]["anthropic"]["settings"]["model"],
"mine"
);
assert_eq!(entry["settings"]["provider"], "ollama");
assert_eq!(entry["settings"]["model"], model);
assert_eq!(entry["settings"]["baseUrl"], "http://127.0.0.1:17434/v1");
assert_eq!(entry["settings"]["keep"], 1);
assert_eq!(
entry["settings"]["timeout"], CLINE_RESPONSE_START_TIMEOUT_MS,
"a missing response-start timeout gets llmman's slow-prefill default"
);
assert!(entry["settings"].get("apiKey").is_none());
assert_eq!(entry["tokenSource"], "manual");
assert_eq!(entry["updatedAt"], "2026-09-20T06:00:00Z");
assert_eq!(entry["other"], true);
assert_eq!(
std::fs::read_to_string(root.join("settings/providers.json.bak")).unwrap(),
providers_original
);
let global: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&global_path).unwrap()).unwrap();
assert_eq!(global["theme"], "mine");
assert_eq!(global["ollamaBaseUrl"], "http://127.0.0.1:17434");
assert_eq!(global["actModeApiProvider"], "ollama");
assert_eq!(global["planModeApiProvider"], "ollama");
assert_eq!(global["actModeOllamaModelId"], model);
assert_eq!(global["planModeOllamaModelId"], model);
assert_eq!(global["actModeOllamaBaseUrl"], "http://127.0.0.1:17434");
assert_eq!(global["planModeOllamaBaseUrl"], "http://127.0.0.1:17434");
assert_eq!(global["welcomeViewCompleted"], true);
assert_eq!(
std::fs::read_to_string(root.join("globalState.json.bak")).unwrap(),
global_original
);
let providers_written = std::fs::read(&providers_path).unwrap();
let global_written = std::fs::read(&global_path).unwrap();
write_cline_settings_at(
&root,
model,
"http://127.0.0.1:17434",
"2026-09-20T07:00:00Z",
)
.unwrap();
assert_eq!(std::fs::read(&providers_path).unwrap(), providers_written);
assert_eq!(std::fs::read(&global_path).unwrap(), global_written);
write_cline_settings_at(
&root,
"new-model",
"http://127.0.0.1:17434",
"2026-09-20T08:00:00Z",
)
.unwrap();
let changed: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&providers_path).unwrap()).unwrap();
assert_eq!(
changed["providers"]["ollama"]["updatedAt"],
"2026-09-20T08:00:00Z"
);
let _ = std::fs::remove_dir_all(root);
}
#[test]
fn cline_settings_keep_a_user_set_response_start_timeout() {
let root = std::env::temp_dir().join(format!(
"llmman-cline-timeout-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let providers_path = root.join("settings/providers.json");
std::fs::create_dir_all(providers_path.parent().unwrap()).unwrap();
std::fs::write(
&providers_path,
r#"{"providers":{"ollama":{"settings":{"timeout":45000}}}}"#,
)
.unwrap();
write_cline_settings_at(
&root,
"some-model",
"http://127.0.0.1:17434",
"2026-09-20T06:00:00Z",
)
.unwrap();
let parsed: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&providers_path).unwrap()).unwrap();
assert_eq!(parsed["providers"]["ollama"]["settings"]["timeout"], 45000);
let _ = std::fs::remove_dir_all(root);
}
#[test]
fn cline_install_contract_uses_latest_and_only_yes_accepts() {
assert_eq!(CLINE_NPM_INSTALL_ARGS, ["install", "-g", "cline@latest"]);
assert_eq!(
CLINE_INSTALL_PROMPT,
"Cline is not installed. Install with npm? [y/N] "
);
assert_eq!(CLINE_INSTALL_CANCELLED, "cline installation cancelled");
for answer in ["y", "Y", "yes", "YES", " yes\n"] {
assert!(accepts_prompt(answer));
}
for answer in ["", "\n", "n", "no", "yep"] {
assert!(!accepts_prompt(answer));
}
}
#[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 cline_dir_follows_cline_dir_then_userprofile_then_home() {
let p = |s: &str| Some(PathBuf::from(s));
let home = || Ok(PathBuf::from("/home"));
let resolve = |dir, profile| resolve_cline_dir(dir, profile, home).unwrap();
assert_eq!(
resolve(p("/explicit"), p("/profile")),
PathBuf::from("/explicit")
);
assert_eq!(
resolve(None, p("/profile")),
PathBuf::from("/profile/.cline")
);
assert_eq!(resolve(None, None), PathBuf::from("/home/.cline"));
}
#[test]
fn grok_env_points_every_model_path_at_llmman() {
let env = grok_env(
"docker.io/ai/qwen3.5:0.8b",
"k",
"http://127.0.0.1:17434/v1",
"http://127.0.0.1:17434/v1/models",
"/tmp/grok/llmman",
);
let get = |key| {
env.iter()
.find(|(name, _)| *name == key)
.map(|(_, value)| *value)
};
assert_eq!(
get("GROK_MODELS_BASE_URL"),
Some("http://127.0.0.1:17434/v1")
);
assert_eq!(get("GROK_HOME"), Some("/tmp/grok/llmman"));
assert_eq!(
get("GROK_MODELS_LIST_URL"),
Some("http://127.0.0.1:17434/v1/models")
);
assert_eq!(get("GROK_DEFAULT_MODEL"), Some("docker.io/ai/qwen3.5:0.8b"));
assert_eq!(
get("GROK_WEB_SEARCH_MODEL"),
Some("docker.io/ai/qwen3.5:0.8b")
);
assert_eq!(
get("GROK_SESSION_SUMMARY_MODEL"),
Some("docker.io/ai/qwen3.5:0.8b")
);
assert_eq!(
get("GROK_IMAGE_DESCRIPTION_MODEL"),
Some("docker.io/ai/qwen3.5:0.8b")
);
assert_eq!(
get("GROK_PROMPT_SUGGESTIONS_MODEL"),
Some("docker.io/ai/qwen3.5:0.8b")
);
assert_eq!(get(GROK_API_KEY_ENV), Some("k"));
assert_eq!(get("XAI_API_KEY"), Some("k"));
}
#[test]
fn grok_config_uses_the_model_credential_without_persisting_it() {
let model = r#"org/model.\"quoted\""#;
let text = grok_config_document(model, "http://127.0.0.1:17434/v1", &[]);
let parsed: toml::Value = text.parse().expect("valid TOML");
let entry = &parsed["model"][model];
assert_eq!(entry["model"].as_str(), Some(model));
assert_eq!(
entry["base_url"].as_str(),
Some("http://127.0.0.1:17434/v1")
);
assert_eq!(entry["env_key"].as_str(), Some(GROK_API_KEY_ENV));
assert_eq!(entry["api_backend"].as_str(), Some("chat_completions"));
assert!(entry.get("api_key").is_none());
}
#[test]
fn grok_config_is_written_only_inside_the_isolated_child_home() {
let root = std::env::temp_dir().join(format!(
"llmman-grok-config-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::create_dir_all(&root).unwrap();
let user_config = root.join("config.toml");
std::fs::write(&user_config, "[model.mine]\napi_key = \"keep-me\"\n").unwrap();
let isolated = root.join("llmman");
write_grok_config(&isolated, "m", "http://127.0.0.1:17434/v1", &[]).unwrap();
assert_eq!(
std::fs::read_to_string(user_config).unwrap(),
"[model.mine]\napi_key = \"keep-me\"\n"
);
assert!(std::fs::read_to_string(isolated.join("config.toml"))
.unwrap()
.contains("LLMMAN_GROK_API_KEY"));
let _ = std::fs::remove_dir_all(root);
}
#[test]
fn grok_args_add_the_model_and_yield_to_an_explicit_override() {
let args = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
assert_eq!(
grok_args("m:latest", &args(&["--single", "hi"])),
["--model", "m:latest", "--single", "hi"]
);
assert_eq!(
grok_args("m:latest", &args(&["-m", "theirs", "--single", "hi"])),
["-m", "theirs", "--single", "hi"]
);
assert_eq!(
grok_args("m:latest", &args(&["--model=theirs"])),
["--model=theirs"]
);
}
#[test]
fn grok_fallback_finds_the_official_installers_target() {
let home = std::env::temp_dir().join(format!(
"llmman-grok-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let bin = home.join(".grok").join("bin");
std::fs::create_dir_all(&bin).unwrap();
assert_eq!(grok_fallback(&home), None);
let grok = bin.join(if cfg!(windows) { "grok.exe" } else { "grok" });
std::fs::create_dir(&grok).unwrap();
assert_eq!(grok_fallback(&home), None, "a directory is not a binary");
std::fs::remove_dir(&grok).unwrap();
std::fs::write(&grok, "").unwrap();
assert_eq!(grok_fallback(&home), Some(grok));
let _ = std::fs::remove_dir_all(&home);
}
#[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 path_with_dir_prepended_only_when_it_is_missing() {
let path_var =
std::env::join_paths([PathBuf::from("/usr/bin"), PathBuf::from("/bin")]).unwrap();
assert_eq!(
path_with_dir_prepended(Some(Path::new("/usr/bin")), &path_var),
None
);
assert_eq!(
path_with_dir_prepended(Some(Path::new("/opt/nvm/bin")), &path_var),
Some(
std::env::join_paths([
PathBuf::from("/opt/nvm/bin"),
PathBuf::from("/usr/bin"),
PathBuf::from("/bin"),
])
.unwrap()
)
);
assert_eq!(path_with_dir_prepended(None, &path_var), None);
assert_eq!(
path_with_dir_prepended(Some(Path::new("/opt/nvm/bin")), std::ffi::OsStr::new("")),
Some(std::ffi::OsString::from("/opt/nvm/bin"))
);
let gappy = std::env::join_paths([
PathBuf::from("/usr/bin"),
PathBuf::from(""),
PathBuf::from("/bin"),
])
.unwrap();
assert_eq!(
path_with_dir_prepended(Some(Path::new("/opt/nvm/bin")), &gappy),
Some(
std::env::join_paths([
PathBuf::from("/opt/nvm/bin"),
PathBuf::from("/usr/bin"),
PathBuf::from("/bin"),
])
.unwrap()
)
);
}
#[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 qwen_args_prefix_auth_type_and_model_unless_the_caller_passed_them() {
let none: Vec<String> = vec![];
assert_eq!(
qwen_args("m:latest", &none),
["--auth-type", "openai", "--model", "m:latest"]
);
let user_model = vec![
"--model".to_string(),
"theirs".to_string(),
"-p".to_string(),
];
assert_eq!(
qwen_args("m:latest", &user_model),
["--auth-type", "openai", "--model", "theirs", "-p"]
);
let user_short = vec!["-m=theirs".to_string()];
assert_eq!(
qwen_args("m:latest", &user_short),
["--auth-type", "openai", "-m=theirs"]
);
let user_auth = vec!["--auth-type=qwen-oauth".to_string()];
assert_eq!(
qwen_args("m:latest", &user_auth),
["--model", "m:latest", "--auth-type=qwen-oauth"]
);
let user_camel = vec!["--authType".to_string(), "openai".to_string()];
assert_eq!(
qwen_args("m:latest", &user_camel),
["--model", "m:latest", "--authType", "openai"]
);
}
#[test]
fn nvm_qwen_finds_it_under_a_node_version() {
let home = std::env::temp_dir().join(format!(
"llmman-nvm-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let bin = home.join(".nvm/versions/node/v22.9.1/bin");
std::fs::create_dir_all(&bin).unwrap();
std::fs::create_dir_all(home.join(".nvm/versions/node/v20.19.0/bin")).unwrap();
std::fs::write(bin.join("qwen"), "").unwrap();
assert_eq!(nvm_qwen(&home), Some(bin.join("qwen")));
assert_eq!(nvm_qwen(&home.join("nowhere")), None);
let _ = std::fs::remove_dir_all(&home);
}
#[cfg(unix)]
#[test]
fn qwen_fallback_paths_name_the_documented_targets() {
let home = dirs::home_dir().unwrap();
let paths = qwen_fallback_paths();
assert!(paths.contains(&home.join(".local/bin/qwen")));
assert!(paths.contains(&home.join(".npm-global/bin/qwen")));
assert!(paths.contains(&home.join(".cargo/bin/qwen")));
assert!(paths.contains(&PathBuf::from("/usr/local/bin/qwen")));
}
#[test]
fn qwen_settings_merge_keeps_what_is_not_llmmans() {
let existing = serde_json::json!({
"$version": 4,
"ui": { "theme": "keep-me" },
"modelProviders": {
"gemini": [ { "id": "gemini-2.5-pro" } ],
"openai": [
{ "id": "docker.io/ai/m:latest", "name": "cloud copy",
"baseUrl": "https://cloud.example/v1",
"envKey": "QWEN_CUSTOM_API_KEY_X", "customField": 1 },
{ "id": "old:latest", "name": "renamed by the user",
"baseUrl": "http://127.0.0.1:17434/v1/", "envKey": "LLMMAN_API_KEY" },
{ "id": "other:latest", "name": "other:latest (llmman)",
"baseUrl": "http://10.0.0.2:17434/v1", "envKey": "LLMMAN_API_KEY" },
{ "id": "local-alias", "name": "my alias for the daemon",
"baseUrl": "http://127.0.0.1:17434/v1", "envKey": "OPENAI_API_KEY",
"generationConfig": { "temperature": 0.2 } }
]
},
"security": { "auth": { "selectedType": "qwen-oauth", "apiKey": "keep-too" } },
"model": { "name": "gemini-2.5-pro", "generationConfig": { "temperature": 0.1 } }
});
let url = "http://127.0.0.1:17434/v1";
let merged = qwen_settings_merged(&existing, "docker.io/ai/m:latest", url, false, None);
assert_eq!(merged["$version"], 4);
assert_eq!(merged["ui"]["theme"], "keep-me");
assert_eq!(
merged["modelProviders"]["gemini"],
existing["modelProviders"]["gemini"]
);
let before = existing["modelProviders"]["openai"].as_array().unwrap();
let openai = merged["modelProviders"]["openai"].as_array().unwrap();
assert_eq!(
openai[0],
serde_json::json!({ "id": "docker.io/ai/m:latest",
"name": "docker.io/ai/m:latest (llmman)", "baseUrl": url,
"envKey": "LLMMAN_API_KEY" })
);
assert_eq!(
openai[1..],
[before[0].clone(), before[2].clone(), before[3].clone()]
);
assert_eq!(merged["security"]["auth"]["selectedType"], "openai");
assert_eq!(merged["security"]["auth"]["baseUrl"], url);
assert_eq!(merged["security"]["auth"]["apiKey"], "keep-too");
assert_eq!(merged["model"]["name"], "docker.io/ai/m:latest");
assert_eq!(merged["model"]["baseUrl"], url);
assert_eq!(merged["model"]["generationConfig"]["temperature"], 0.1);
}
#[test]
fn qwen_settings_merge_is_complete_from_nothing_and_idempotent() {
let url = "http://127.0.0.1:17434/v1";
let once = qwen_settings_merged(&serde_json::json!({}), "m:latest", url, false, None);
assert_eq!(
once,
serde_json::json!({
"modelProviders": { "openai": [ { "id": "m:latest",
"name": "m:latest (llmman)", "baseUrl": url,
"envKey": "LLMMAN_API_KEY" } ] },
"security": { "auth": { "selectedType": "openai", "baseUrl": url } },
"model": { "name": "m:latest", "baseUrl": url }
})
);
assert_eq!(
qwen_settings_merged(&once, "m:latest", url, false, None),
once
);
let text = once.to_string();
assert!(!text.contains("apiKey") && !text.contains("\"env\""));
assert!(!PROVIDER_NEEDS_DAEMON_KEY.contains(&"qwen"));
}
#[test]
fn qwen_keeps_image_input_only_for_the_model_it_was_read_from() {
let resolved = crate::shortnames::resolve_ollama_api("gemma4:12b").unwrap();
let forwarded = |m: &str| vec![String::from("--model"), String::from(m)];
let cases = [
(Vec::new(), resolved.as_str(), true),
(forwarded("gemma4:12b"), "gemma4:12b", true),
(forwarded(&resolved), resolved.as_str(), true),
(forwarded("qwen3.5:0.8b"), "qwen3.5:0.8b", false),
(forwarded("not a reference"), "not a reference", false),
];
for (extra_args, model, vision) in cases {
assert_eq!(
qwen_model_and_vision(&resolved, true, &extra_args),
(model, vision),
"{extra_args:?}"
);
}
}
#[test]
fn qwen_settings_declare_image_input_only_for_a_vision_model() {
let url = "http://h/v1";
let vision = qwen_settings_merged(&serde_json::json!({}), "m", url, true, None);
assert_eq!(
vision["modelProviders"]["openai"][0]["generationConfig"],
serde_json::json!({ "modalities": { "image": true } })
);
assert!(vision["model"].get("generationConfig").is_none());
let text_only = qwen_settings_merged(&vision, "m", url, false, None);
assert!(!text_only.to_string().contains("modalities"), "{text_only}");
}
#[test]
fn qwen_settings_merge_replaces_a_wrong_typed_value_on_its_path() {
let existing = serde_json::json!({
"security": 3, "modelProviders": { "openai": "x" }, "model": []
});
let merged = qwen_settings_merged(&existing, "m", "http://h/v1", false, None);
assert_eq!(merged["security"]["auth"]["selectedType"], "openai");
assert_eq!(merged["modelProviders"]["openai"][0]["id"], "m");
assert_eq!(merged["model"]["name"], "m");
let from_null =
qwen_settings_merged(&serde_json::json!(null), "m", "http://h/v1", false, None);
assert_eq!(from_null["model"]["name"], "m");
let wrapped = serde_json::json!({
"$version": 5,
"modelProviders": { "openai": { "protocol": "openai", "models": [
{ "id": "gpt-5", "baseUrl": "https://api.openai.com/v1", "envKey": "MY_KEY" }
] } }
});
let merged = qwen_settings_merged(&wrapped, "m", "http://h/v1", false, None);
let openai = merged["modelProviders"]["openai"].as_array().unwrap();
assert_eq!(openai.len(), 2);
assert_eq!(openai[1]["id"], "gpt-5");
assert_eq!(merged["$version"], 4, "the version follows the shape");
}
#[test]
fn qwen_entry_is_ours_needs_the_key_name_and_the_address() {
let url = "http://127.0.0.1:17434/v1";
let ours = serde_json::json!({ "id": "anything", "name": "renamed by the user",
"baseUrl": "http://127.0.0.1:17434/v1/", "envKey": "LLMMAN_API_KEY" });
assert!(qwen_entry_is_ours(&ours, url));
let hand_written = serde_json::json!({ "id": "local-alias", "name": "m (llmman)",
"baseUrl": url, "envKey": "OPENAI_API_KEY" });
assert!(!qwen_entry_is_ours(&hand_written, url));
let elsewhere = serde_json::json!({ "id": "m:latest", "name": "m:latest (llmman)",
"baseUrl": "http://10.0.0.2:17434/v1", "envKey": "LLMMAN_API_KEY" });
assert!(!qwen_entry_is_ours(&elsewhere, url));
assert!(!qwen_entry_is_ours(
&serde_json::json!("not an object"),
url
));
}
#[test]
fn pi_agent_dir_reads_the_home_node_reads() {
assert_eq!(
crate::config::home_dir(),
node_user_profile().or_else(dirs::home_dir)
);
if cfg!(windows) {
assert_eq!(node_user_profile(), env_dir("USERPROFILE"));
} else {
assert_eq!(node_user_profile(), None);
}
}
#[test]
fn pi_model_entry_declares_what_the_daemon_serves() {
let entry = pi_model_entry("qwen3.5:0.8b", true, true, Some(32768));
assert_eq!(entry["id"], "qwen3.5:0.8b");
assert_eq!(entry["name"], "qwen3.5:0.8b");
assert_eq!(entry["input"], serde_json::json!(["text", "image"]));
assert_eq!(entry["reasoning"], true);
assert_eq!(entry["contextWindow"], 32768);
let plain = pi_model_entry("smol", false, false, None);
assert_eq!(plain["input"], serde_json::json!(["text"]));
assert_eq!(plain.get("reasoning"), None);
assert_eq!(plain.get("contextWindow"), None);
}
#[test]
fn pi_model_entry_declares_the_resolved_window_not_the_trained_context() {
let pair = pair_context_window(Some(32_768), Some(200_000));
assert_eq!(pair, Some(200_000));
let entry = pi_model_entry("gemma4", false, false, pair);
assert_eq!(entry["contextWindow"], 200_000);
let default = u64::from(super::super::serve::DEFAULT_CTX_SIZE);
let served = served_context_window(None, Some(1 << 20));
assert_eq!(served, Some(default));
let entry = pi_model_entry("big", false, false, served);
assert_eq!(entry["contextWindow"], default);
}
#[test]
fn pi_models_merged_keeps_other_providers_and_hand_added_models() {
let existing: serde_json::Value = serde_json::from_str(
r#"{
"providers": {
"other": { "baseUrl": "https://example.invalid/v1" },
"llmman": {
"headers": { "X-Trace": "1" },
"apiKey": "mine-not-yours",
"models": [{ "id": "mine" }, { "id": "stale" }]
}
}
}"#,
)
.unwrap();
let entry = pi_model_entry("qwen3.5:0.8b", false, false, None);
let merged = pi_models_merged(&existing, "http://127.0.0.1:17434", &entry);
assert_eq!(
merged["providers"]["other"]["baseUrl"],
"https://example.invalid/v1"
);
assert_eq!(
merged["providers"]["llmman"]["baseUrl"],
"http://127.0.0.1:17434/v1"
);
assert_eq!(merged["providers"]["llmman"]["headers"]["X-Trace"], "1");
assert_eq!(merged["providers"]["llmman"]["apiKey"], "mine-not-yours");
let ids: Vec<&str> = merged["providers"]["llmman"]["models"]
.as_array()
.unwrap()
.iter()
.map(|m| m["id"].as_str().unwrap())
.collect();
assert_eq!(ids, vec!["mine", "stale", "qwen3.5:0.8b"]);
}
#[test]
fn pi_models_merged_survives_a_wrong_shaped_providers_value() {
for raw in [r#"{"providers": []}"#, r#"{"providers": "x"}"#, r#"{}"#] {
let existing: serde_json::Value = serde_json::from_str(raw).unwrap();
let entry = pi_model_entry("m", false, false, None);
let merged = pi_models_merged(&existing, "http://s", &entry);
assert_eq!(merged["providers"]["llmman"]["baseUrl"], "http://s/v1");
assert_eq!(merged["providers"]["llmman"]["models"][0]["id"], "m");
}
}
#[test]
fn pi_models_merged_writes_the_placeholder_key_into_a_fresh_provider() {
let entry = pi_model_entry("m", false, false, None);
let merged = pi_models_merged(&serde_json::json!({}), "http://127.0.0.1:17434", &entry);
let provider = &merged["providers"]["llmman"];
assert_eq!(provider["baseUrl"], "http://127.0.0.1:17434/v1");
assert_eq!(provider["api"], "openai-completions");
assert_eq!(provider["apiKey"], "llmman");
}
#[test]
fn pi_models_merged_keeps_a_previously_launched_model() {
let first = pi_model_entry("a", false, false, None);
let one = pi_models_merged(&serde_json::json!({}), "http://s", &first);
let two = pi_models_merged(&one, "http://s", &pi_model_entry("b", false, false, None));
let ids: Vec<&str> = two["providers"]["llmman"]["models"]
.as_array()
.unwrap()
.iter()
.map(|m| m["id"].as_str().unwrap())
.collect();
assert_eq!(ids, vec!["a", "b"]);
}
#[test]
fn pi_settings_merged_leaves_unrelated_settings_alone() {
let existing = serde_json::json!({ "theme": "dark", "defaultModel": "old" });
let merged = pi_settings_merged(&existing, "qwen3.5:0.8b");
assert_eq!(merged["theme"], "dark");
assert_eq!(merged["defaultProvider"], "llmman");
assert_eq!(merged["defaultModel"], "qwen3.5:0.8b");
}
#[test]
fn write_qwen_settings_at_writes_once_keeps_a_bak_and_refuses_non_json() {
let dir = std::env::temp_dir().join(format!(
"llmman-qwen-settings-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let url = "http://127.0.0.1:17434/v1";
let path = dir.join("settings.json");
let bak = dir.join("settings.json.bak");
let read = || -> serde_json::Value {
serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap()
};
write_qwen_settings_at(&dir, "m:latest", url, false, None).unwrap();
assert_eq!(read()["model"]["name"], "m:latest");
assert!(!bak.exists(), "nothing to back up on a first write");
let written = std::fs::metadata(&path).unwrap().modified().unwrap();
std::thread::sleep(std::time::Duration::from_millis(20));
write_qwen_settings_at(&dir, "m:latest", url, false, None).unwrap();
assert_eq!(
std::fs::metadata(&path).unwrap().modified().unwrap(),
written
);
let commented = "{\n // mine\n \"ui\": { \"theme\": \"x\" }\n}\n";
std::fs::write(&path, commented).unwrap();
write_qwen_settings_at(&dir, "m:latest", url, false, None).unwrap();
assert_eq!(read()["ui"]["theme"], "x");
assert_eq!(read()["model"]["name"], "m:latest");
assert_eq!(std::fs::read_to_string(&bak).unwrap(), commented);
write_qwen_settings_at(&dir, "other:latest", url, false, None).unwrap();
assert_eq!(read()["model"]["name"], "other:latest");
assert_eq!(
std::fs::read_to_string(&bak).unwrap(),
commented,
"llmman's own rendering must not replace the user's backup"
);
let edited = "{\n // edited by hand\n \"ui\": { \"theme\": \"y\" }\n}\n";
std::fs::write(&path, edited).unwrap();
write_qwen_settings_at(&dir, "m:latest", url, false, None).unwrap();
assert_eq!(std::fs::read_to_string(&bak).unwrap(), edited);
std::fs::write(&path, " \n").unwrap();
write_qwen_settings_at(&dir, "m:latest", url, false, None).unwrap();
assert_eq!(read()["model"]["name"], "m:latest");
std::fs::write(&path, "{ not json").unwrap();
write_qwen_settings_at(&dir, "m:latest", url, false, None).unwrap();
assert_eq!(std::fs::read_to_string(&path).unwrap(), "{ not json");
std::fs::write(&path, "[]").unwrap();
write_qwen_settings_at(&dir, "m:latest", url, false, None).unwrap();
assert_eq!(std::fs::read_to_string(&path).unwrap(), "[]");
let _ = std::fs::remove_dir_all(&dir);
}
#[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("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 write_dsh_settings_points_at_llmman_with_the_key_in_the_environment() {
let dir = std::env::temp_dir().join(format!(
"llmman-dsh-settings-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let path = dir.join("settings.yaml");
write_dsh_settings(&path, "qwen3.5:0.8b", false, None).unwrap();
let contents = std::fs::read_to_string(&path).unwrap();
assert!(contents.contains("provider: llmman"));
assert!(contents.contains("model: \"qwen3.5:0.8b\""));
assert!(contents.contains(&format!("apiKeyEnv: {DSH_API_KEY_ENV}")));
assert!(contents.contains("api: openai-completions"));
assert!(contents.contains(&format!("baseURL: \"{}/v1\"", daemon::server())));
assert!(contents.contains("id: \"qwen3.5:0.8b\""));
assert!(!contents.contains("apiKey:"), "no literal key in the file");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn write_dsh_settings_declares_image_input_only_for_a_vision_model() {
let dir = std::env::temp_dir().join(format!(
"llmman-dsh-vision-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let path = dir.join("settings.yaml");
write_dsh_settings(&path, "m", true, None).unwrap();
assert!(std::fs::read_to_string(&path)
.unwrap()
.contains("input: [text, image]"));
write_dsh_settings(&path, "m", false, None).unwrap();
assert!(std::fs::read_to_string(&path)
.unwrap()
.contains("input: [text]"));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn dsh_falls_back_to_the_published_package_under_npx() {
let dsh = PathBuf::from("/usr/local/bin/dsh");
let npx = PathBuf::from("/usr/local/bin/npx");
assert_eq!(
dsh_command(Some(dsh.clone()), || panic!("npx looked up anyway")),
Some((dsh, Vec::new()))
);
assert_eq!(
dsh_command(None, || Some(npx.clone())),
Some((npx, vec!["--yes".to_string(), DSH_NPM_PACKAGE.to_string()]))
);
assert!(DSH_NPM_PACKAGE.starts_with("@deepseek-ai/dsh@"));
assert_eq!(dsh_command(None, || None), None);
}
#[test]
fn write_dsh_patch_names_the_settings_document() {
let dir = std::env::temp_dir().join(format!(
"llmman-dsh-patch-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let settings_path = dir.join("settings.yaml");
let patch_path = dir.join("llmman.cordis.yml");
write_dsh_patch(&patch_path, &settings_path).unwrap();
let contents = std::fs::read_to_string(&patch_path).unwrap();
assert!(contents.contains("id: settings"));
assert!(contents.contains(&format!(
"path: {}",
common::yaml_quote(&settings_path.to_string_lossy())
)));
let _ = std::fs::remove_dir_all(&dir);
let win = Path::new(r"C:\Users\hb\.config\llmman\launch\dsh\settings.yaml");
let rendered = dsh_patch_document(win);
assert!(rendered.contains(r#"path: "C:\\Users\\hb\\"#), "{rendered}");
assert!(!rendered.contains(r#"path: "C:\Users"#), "{rendered}");
}
#[test]
fn dsh_checks_stop_at_dshs_own_argument_boundary() {
let args = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
let forwarded_patch = args(&["--profile", "headless", "--", "--patch"]);
assert_eq!(
dsh_launcher(&forwarded_patch).args,
args(&["--profile", "headless"])
);
assert!(!has_flag(
dsh_launcher(&forwarded_patch).args,
"--patch",
None
));
let forwarded_profile = args(&["--", "--profile", "headless"]);
assert!(dsh_launcher(&forwarded_profile).args.is_empty());
assert_eq!(
dsh_args(Path::new("/p.yml"), &forwarded_profile),
["web", "--patch", "/p.yml", "--", "--profile", "headless"]
);
let task_mentions_patch = args(&["--profile", "headless", "explain", "the", "--patch"]);
assert_eq!(
dsh_launcher(&task_mentions_patch).args,
args(&["--profile", "headless"])
);
assert!(!has_flag(
dsh_launcher(&task_mentions_patch).args,
"--patch",
None
));
let app_level_profile = args(&["sometask", "--profile", "headless"]);
assert!(dsh_launcher(&app_level_profile).args.is_empty());
assert_eq!(
dsh_args(Path::new("/p.yml"), &app_level_profile),
[
"web",
"--patch",
"/p.yml",
"sometask",
"--profile",
"headless"
]
);
assert_eq!(
dsh_launcher(&args(&["--dump-config", "task"])).args,
args(&["--dump-config"])
);
assert_eq!(
dsh_launcher(&args(&["--profile=headless", "task"])).args,
args(&["--profile=headless"])
);
for command in ["web", "plugin"] {
let via_command = args(&[command, "--port", "8080"]);
assert_eq!(dsh_launcher(&via_command).command, Some(command));
let err = launch_dsh("m", "k", false, None, &via_command).unwrap_err();
assert!(err.to_string().contains("--profile"), "{err}");
}
let profile_web = args(&["--profile", "web", "--no-open"]);
assert_eq!(dsh_launcher(&profile_web).command, None);
assert_eq!(
dsh_args(Path::new("/p.yml"), &profile_web),
["--patch", "/p.yml", "--profile", "web", "--no-open"]
);
assert_eq!(dsh_launcher(&args(&["--patch", "web"])).command, None);
assert_eq!(dsh_launcher(&args(&["sometask", "web"])).command, None);
let plain = args(&["--profile", "headless"]);
assert_eq!(dsh_launcher(&plain).args, plain);
assert_eq!(
dsh_launcher(&args(&["--profile"])).args,
args(&["--profile"])
);
}
#[test]
fn launch_dsh_refuses_a_conflicting_patch_flag() {
let word = vec!["--patch".to_string(), "/tmp/x.yml".to_string()];
let err = launch_dsh("m", "k", false, None, &word).unwrap_err();
assert!(err.to_string().contains("--patch"), "{err}");
let joined = vec!["--patch=/tmp/x.yml".to_string()];
let err = launch_dsh("m", "k", false, None, &joined).unwrap_err();
assert!(err.to_string().contains("--patch"), "{err}");
}
#[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 dsh_args_defaults_to_web_but_yields_to_a_caller_supplied_profile() {
let path = Path::new("/tmp/x/llmman.cordis.yml");
let none: Vec<String> = vec![];
assert_eq!(
dsh_args(path, &none),
["web", "--patch", "/tmp/x/llmman.cordis.yml"]
);
let headless = vec![
"--profile".to_string(),
"headless".to_string(),
"hi".to_string(),
];
assert_eq!(
dsh_args(path, &headless),
[
"--patch",
"/tmp/x/llmman.cordis.yml",
"--profile",
"headless",
"hi"
]
);
let joined = vec!["--profile=headless".to_string(), "hi".to_string()];
assert_eq!(
dsh_args(path, &joined),
[
"--patch",
"/tmp/x/llmman.cordis.yml",
"--profile=headless",
"hi"
]
);
}
#[test]
fn strip_yaml_top_level_key_removes_only_that_key_and_its_block() {
let existing = "\
toolsets:\n - web\nmodel:\n provider: llmman\n default: old-model\nproviders:\n llmman:\n name: llmman\nchannels:\n telegram: {}\n";
let cleaned =
strip_yaml_top_level_key(&strip_yaml_top_level_key(existing, "model"), "providers");
assert!(!cleaned.contains("model:"));
assert!(!cleaned.contains("provider: llmman"));
assert!(!cleaned.contains("providers:"));
assert!(cleaned.contains("toolsets:"));
assert!(cleaned.contains(" - web"));
assert!(cleaned.contains("channels:"));
assert!(cleaned.contains(" telegram: {}"));
}
#[test]
fn hermes_config_declares_image_input_only_for_a_vision_model() {
let vision = hermes_config_blocks("m", "http://h/v1", true);
let model_block = strip_yaml_top_level_key(&vision, "providers");
assert!(
model_block.contains("\n supports_vision: true\n"),
"{vision}"
);
let text_only = hermes_config_blocks("m", "http://h/v1", false);
assert!(!text_only.contains("supports_vision"), "{text_only}");
assert_eq!(text_only, vision.replace(" supports_vision: true\n", ""));
}
#[test]
fn strip_yaml_top_level_key_is_a_no_op_without_that_key() {
let existing = "toolsets:\n - web\n";
assert_eq!(strip_yaml_top_level_key(existing, "model"), existing);
}
#[test]
fn strip_yaml_top_level_key_handles_blank_lines_inside_the_removed_block() {
let existing = "toolsets:\n - web\n\nmodel:\n provider: llmman\n\n default: old-model\n\nchannels:\n telegram: {}\n";
let cleaned = strip_yaml_top_level_key(existing, "model");
assert!(!cleaned.contains("model:"));
assert!(!cleaned.contains("provider: llmman"));
assert!(!cleaned.contains("default: old-model"));
assert!(cleaned.contains("toolsets:"));
assert!(cleaned.contains("channels:"));
assert!(cleaned.contains(" telegram: {}"));
}
#[test]
fn strip_yaml_top_level_key_handles_a_comment_inside_the_removed_block() {
let existing = "toolsets:\n - web\n# a comment\nmodel:\n provider: llmman\n# another comment\n default: old-model\nchannels:\n telegram: {}\n";
let cleaned = strip_yaml_top_level_key(existing, "model");
assert!(!cleaned.contains("model:"));
assert!(!cleaned.contains("provider: llmman"));
assert!(!cleaned.contains("default: old-model"));
assert!(!cleaned.contains("another comment"));
assert!(cleaned.contains("toolsets:"));
assert!(cleaned.contains("# a comment"));
assert!(cleaned.contains("channels:"));
assert!(cleaned.contains(" telegram: {}"));
}
#[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 docker_agent_args_lead_with_run_and_the_generated_agent_file() {
let path = Path::new("/tmp/llmman/agent.yaml");
let extra = ["--exec".to_string(), "say pong".to_string()];
assert_eq!(
docker_agent_args(path, &extra),
vec![
"run".to_string(),
"/tmp/llmman/agent.yaml".to_string(),
"--exec".to_string(),
"say pong".to_string(),
]
);
assert_eq!(
docker_agent_args(path, &[]),
vec!["run".to_string(), "/tmp/llmman/agent.yaml".to_string()]
);
}
#[test]
fn docker_agent_document_routes_an_openai_provider_model_at_the_daemon() {
let document = docker_agent_document("m", "http://127.0.0.1:17434/v1");
assert!(document.contains("provider: openai"), "{document}");
assert!(document.contains("model: \"m\""), "{document}");
assert!(
document.contains("base_url: \"http://127.0.0.1:17434/v1\""),
"{document}"
);
assert!(
document.contains(&format!(" {DOCKER_AGENT_MODEL_NAME}:")),
"{document}"
);
assert!(
document.contains(&format!("model: {DOCKER_AGENT_MODEL_NAME}\n")),
"{document}"
);
}
#[test]
fn docker_agent_document_names_the_key_variable_rather_than_a_key() {
let document = docker_agent_document("m", "http://127.0.0.1:17434/v1");
assert!(
document.contains(&format!("token_key: {DOCKER_AGENT_API_KEY_ENV}")),
"{document}"
);
assert!(!document.contains("api_key"), "{document}");
assert!(!document.contains("sk-"), "{document}");
}
#[test]
fn docker_agent_document_gives_the_agent_shell_and_filesystem() {
let document = docker_agent_document("m", "http://127.0.0.1:17434/v1");
assert!(document.contains("instruction:"), "{document}");
assert!(document.contains("toolsets:"), "{document}");
assert!(document.contains("- type: shell"), "{document}");
assert!(document.contains("- type: filesystem"), "{document}");
}
#[test]
fn docker_agent_document_quotes_the_values_it_interpolates() {
let document = docker_agent_document("docker.io/ai/qwen3.5:0.8b", "http://h:1/v1");
assert!(
document.contains("model: \"docker.io/ai/qwen3.5:0.8b\""),
"{document}"
);
assert!(
document.contains("base_url: \"http://h:1/v1\""),
"{document}"
);
}
#[test]
fn docker_agent_spots_a_caller_supplied_agent_file() {
for file in ["team.yaml", "./agent.yml", "/tmp/AGENT.YAML", "infra.hcl"] {
let extra = [file.to_string(), "do the thing".to_string()];
assert_eq!(
docker_agent_config_argument_with(&extra, |_| true).map(String::as_str),
Some(file),
"{file} was not recognized as an agent file"
);
}
}
#[test]
fn docker_agent_does_not_mistake_a_message_or_a_flag_value_for_an_agent_file() {
let cases: &[(&str, &[&str])] = &[
(
"a message that ends in .yaml",
&["--exec", "summarize the config.yaml"],
),
("a flag's value", &["--prompt-file", "notes.yaml"]),
("a leading flag", &["--exec", "--yolo", "say pong"]),
("a question about a file", &["what does agent.yaml do?"]),
];
for (why, args) in cases {
let extra: Vec<String> = args.iter().map(|a| a.to_string()).collect();
assert_eq!(
docker_agent_config_argument_with(&extra, |_| true),
None,
"refused {why}: {args:?}"
);
}
let absent = ["explain agent.yaml".to_string()];
assert_eq!(docker_agent_config_argument_with(&absent, |_| false), None);
}
#[test]
fn docker_agent_names_its_agent_file_after_the_model() {
let dir = Path::new("/tmp/llmman/launch/docker-agent");
let file = |model: &str| docker_agent_agent_file(dir, model);
let name = |model: &str| {
file(model)
.file_name()
.and_then(|n| n.to_str())
.unwrap()
.to_string()
};
assert!(
name("docker.io/ai/qwen3.5:0.8b").starts_with("agent-docker.io-ai-qwen3.5-0.8b-"),
"{}",
name("docker.io/ai/qwen3.5:0.8b")
);
for (one, other) in [
("docker.io/ai/qwen3.5:0.8b", "docker.io/ai/qwen3.5:9b"),
("docker.io/ai/qwen3.5:0.8b", "docker.io/ai/gemma4:12b"),
("qwen/qwen3-coder", "qwen/qwen3-max"),
("a/b-c:d", "a/b:c-d"),
(
&format!("{}one", "m".repeat(DOCKER_AGENT_NAME_MAX)),
&format!("{}two", "m".repeat(DOCKER_AGENT_NAME_MAX)),
),
] {
assert_ne!(file(one), file(other), "{one} and {other} share a file");
}
assert!(name(&"x".repeat(4096)).len() <= 255, "name is unbounded");
for model in ["a/b", "a:b", "a\\b", "a b", "a*b", "a?b", "a\"b", "..", "."] {
let file = docker_agent_agent_file(dir, model);
assert_eq!(file.parent(), Some(dir), "{model} escaped its directory");
let name = file.file_name().and_then(|n| n.to_str()).unwrap();
assert!(
name.starts_with("agent-") && name.ends_with(".yaml"),
"{name}"
);
assert!(
!name.contains(std::path::MAIN_SEPARATOR) && name != ".." && name != ".",
"{model} produced {name}"
);
}
}
#[test]
fn docker_agent_fallback_finds_the_cli_plugin_directory() {
let home = std::env::temp_dir().join(format!(
"llmman-docker-agent-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let plugins = home.join(".docker").join("cli-plugins");
std::fs::create_dir_all(&plugins).unwrap();
assert_eq!(docker_agent_fallback(&home), None);
let binary = plugins.join(if cfg!(windows) {
"docker-agent.exe"
} else {
"docker-agent"
});
std::fs::create_dir(&binary).unwrap();
assert_eq!(
docker_agent_fallback(&home),
None,
"a directory is not a binary"
);
std::fs::remove_dir(&binary).unwrap();
std::fs::write(&binary, "").unwrap();
assert_eq!(docker_agent_fallback(&home), Some(binary));
let _ = std::fs::remove_dir_all(&home);
}
#[test]
fn docker_agent_reads_a_model_flag_after_the_terminator_as_a_message() {
let args = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
assert!(check_docker_agent_args(&args(&["--exec", "--", "--model=foo"])).is_ok());
assert!(check_docker_agent_args(&args(&["--exec", "--", "--model", "foo"])).is_ok());
assert!(check_docker_agent_args(&args(&["--exec", "--model=foo"])).is_err());
assert!(check_docker_agent_args(&args(&["--model", "foo", "--", "hi"])).is_err());
}
#[test]
fn docker_agent_refuses_a_forwarded_model_flag() {
for spelling in ["--model", "--model=openai/gpt-5"] {
let extra = [spelling.to_string(), "openai/gpt-5".to_string()];
let error = launch_docker_agent("m", "k", &extra)
.unwrap_err()
.to_string();
assert!(error.contains("api.openai.com"), "{spelling}: {error}");
}
}
#[test]
fn docker_agent_leaves_an_unrelated_short_flag_to_docker_agent() {
for spelling in ["-m", "-m=openai/gpt-5"] {
let extra = [spelling.to_string(), "openai/gpt-5".to_string()];
assert!(
!has_flag(&extra, "--model", None),
"{spelling} was read as --model"
);
}
assert!(has_flag(&["--model".to_string()], "--model", None));
}
#[test]
fn docker_agent_refuses_a_caller_supplied_agent_file_with_the_way_forward() {
let path = std::env::temp_dir().join(format!(
"llmman-docker-agent-{}-{}.yaml",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::write(&path, "agents: {}\n").unwrap();
let named = path.to_string_lossy().into_owned();
let error = launch_docker_agent("m", "k", std::slice::from_ref(&named))
.unwrap_err()
.to_string();
let _ = std::fs::remove_file(&path);
assert!(error.contains(&named), "{error}");
assert!(error.contains("provider: openai"), "{error}");
assert!(error.contains(DOCKER_AGENT_API_KEY_ENV), "{error}");
}
#[test]
fn docker_agent_agent_file_error_does_not_escape_a_windows_path() {
let windows = r"C:\Users\me\AppData\Local\Temp\team.yaml";
let error = docker_agent_own_agent_file_error(windows);
assert!(error.contains(windows), "{error}");
assert!(!error.contains(r"\\"), "separators were doubled: {error}");
}
#[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 qwen_settings_start_the_entry_at_the_variant() {
let url = "http://h/v1";
let high = Effort {
default: "high",
levels: vec!["none", "low", "high"],
};
let saved = serde_json::json!({ "model": { "reasoningEffort": "low" } });
let doc = qwen_settings_merged(&saved, "m", url, true, Some(&high));
assert!(doc["model"]["reasoningEffort"].is_null());
let ours = &doc["modelProviders"]["openai"][0];
assert_eq!(
ours["capabilities"]["reasoning"],
serde_json::json!({
"thinking": true,
"disableField": "reasoning_effort",
"profile": "openai-effort",
"efforts": ["low", "high"],
"defaultEffort": "high",
})
);
assert_eq!(
ours["generationConfig"],
serde_json::json!({ "modalities": { "image": true }, "reasoning": { "effort": "high" } })
);
let off = Effort {
default: "none",
..high
};
let doc = qwen_settings_merged(&serde_json::json!({}), "m", url, false, Some(&off));
let ours = &doc["modelProviders"]["openai"][0];
assert_eq!(ours["generationConfig"]["reasoning"], false);
assert!(ours["capabilities"]["reasoning"]["defaultEffort"].is_null());
}
#[test]
fn grok_config_lists_the_variants_levels() {
let text = grok_config_document("m", "http://h/v1", &["none", "high"]);
let parsed: toml::Value = text.parse().expect("valid TOML");
assert_eq!(
parsed["model"]["m"]["reasoning_efforts"],
toml::Value::Array(vec!["none".into(), "high".into()])
);
let text = grok_config_document("m", "http://h/v1", &[]);
assert!(!text.contains("reasoning_efforts"), "{text}");
}
#[test]
fn dsh_settings_start_the_route_at_the_variant() {
let path = std::env::temp_dir()
.join(format!("llmman-dsh-variant-{}", std::process::id()))
.join("settings.yaml");
let effort = Effort {
default: "low",
levels: vec!["off", "low", "high"],
};
write_dsh_settings(&path, "m", false, Some(&effort)).unwrap();
let contents = std::fs::read_to_string(&path).unwrap();
let _ = std::fs::remove_dir_all(path.parent().unwrap());
let doc: serde_json::Value = yaml_serde::from_str(&contents).expect("valid YAML");
let route = &doc["llm-pi-ai"]["providers"]["llmman"];
assert_eq!(route["reasoning"], "low");
assert_eq!(route["baseURL"], format!("{}/v1", daemon::server()));
assert_eq!(
route["models"][0]["reasoningEfforts"],
serde_json::json!({ "off": "none", "low": "low", "high": "high" })
);
}
}