use std::path::{Path, PathBuf};
use std::process::Command;
use anyhow::Context;
use base64::Engine as _;
use clap::Args;
use crate::chat_template::ThinkingControls;
use crate::daemon;
use crate::providers;
#[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(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(());
};
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"
);
let mut thinking = None;
let mut vision = false;
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());
resolve_provider_model(provider, args.model.as_deref(), name, per_request)?
}
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();
vision = info.vision();
}
match overflow {
Some((provider, hosted)) => {
check_provider_supported(name)?;
let per_request =
!PROVIDER_NEEDS_DAEMON_KEY.contains(&name.to_lowercase().as_str());
let (remote, api_key) =
resolve_provider_model(provider, Some(hosted), name, per_request)?;
(crate::hybrid::pair_with_local(&model, &remote)?, api_key)
}
None => (model, integration_key()),
}
}
};
launch(
name,
&model,
&api_key,
thinking.as_ref(),
vision,
&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"];
const MODEL_FLAG_FORWARDED: &[&str] = &["qwen", "goose"];
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)] = &[
(
"cline",
"it selects its own model rather than taking one from llmman",
),
(
"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",
),
];
const PROVIDER_NEEDS_DAEMON_KEY: &[&str] = &["hermes"];
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(())
}
fn resolve_provider_model(
provider: &str,
model: Option<&str>,
integration: &str,
key_travels_per_request: bool,
) -> anyhow::Result<(String, String)> {
let entry = daemon::provider(provider)?;
let model = model
.map(str::trim)
.filter(|m| !m.is_empty())
.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((providers::format_remote_ref(provider, model), key))
}
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: "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",
},
];
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!(" {:<12} {}{}", i.name, i.description, how);
}
println!("\nUsage: llmman launch <integration> [--model <model>] [--provider <provider>]");
println!(" llmman providers (the providers --provider accepts)");
}
const WINDOWS_PATH_EXTS: &[&str] = &["exe", "cmd", "bat"];
fn find_on_path(binary: &str) -> Option<PathBuf> {
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() {
return Some(candidate);
}
}
} else {
let candidate = dir.join(binary);
if candidate.is_file() {
return Some(candidate);
}
}
}
None
}
fn find_integration_binary(i: &Integration) -> Option<PathBuf> {
match i.name {
"opencode" => find_opencode(),
"qwen" => find_qwen(),
"dsh" => find_dsh().map(|(bin, _)| bin),
"goose" => find_goose(),
_ => find_on_path(i.binary),
}
}
fn launch(
name: &str,
model: &str,
api_key: &str,
thinking: Option<&ThinkingControls>,
vision: bool,
extra_args: &[String],
) -> anyhow::Result<()> {
match name.to_lowercase().as_str() {
"claude" => launch_claude(model, api_key, extra_args),
"opencode" => launch_opencode(model, api_key, thinking, extra_args),
"codex" => launch_codex(model, api_key, extra_args),
"cline" => launch_simple("cline", model, extra_args),
"aider" => launch_aider(model, api_key, extra_args),
"copilot" | "copilot-cli" => launch_copilot(model, extra_args),
"kimi" => launch_simple("kimi", model, extra_args),
"gemini" => launch_gemini(model, api_key, extra_args),
"agy" => launch_agy(model, api_key, extra_args),
"hermes" => launch_hermes(model, extra_args),
"openclaw" => launch_openclaw(model, extra_args),
"qwen" => launch_qwen(model, api_key, extra_args),
"dsh" => launch_dsh(model, api_key, vision, extra_args),
"goose" => launch_goose(model, api_key, extra_args),
other => anyhow::bail!(
"unknown integration {:?}\nRun 'llmman launch' without arguments to list supported integrations.",
other
),
}
}
fn launch_claude(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin = find_on_path("claude").ok_or_else(|| anyhow::anyhow!("claude 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 server = daemon::server();
exec_with_env(
&bin,
&args,
&[
("ANTHROPIC_BASE_URL", server.as_str()),
("ANTHROPIC_API_KEY", api_key),
],
)
}
fn launch_opencode(
model: &str,
api_key: &str,
thinking: Option<&ThinkingControls>,
extra_args: &[String],
) -> anyhow::Result<()> {
let bin = find_opencode().ok_or_else(|| anyhow::anyhow!("opencode is not installed"))?;
let effective_model = if model.is_empty() { "default" } else { model };
let config = opencode_config(
&daemon::server(),
effective_model,
api_key,
&opencode_variants(thinking),
);
exec_with_env(&bin, extra_args, &[("OPENCODE_CONFIG_CONTENT", &config)])
}
const PORTABLE_THINKING_LEVELS: &[&str] = &["none", "low", "medium", "high"];
fn opencode_variants(
thinking: Option<&ThinkingControls>,
) -> Vec<(&'static str, serde_json::Value)> {
let choices = match thinking {
Some(controls) => controls.choices(),
None => PORTABLE_THINKING_LEVELS.to_vec(),
};
choices
.into_iter()
.map(|choice| {
let options = match choice {
"thinking" => {
serde_json::json!({ "chat_template_kwargs": { "enable_thinking": true } })
}
level => serde_json::json!({ "reasoningEffort": level }),
};
(choice, options)
})
.collect()
}
fn find_opencode() -> Option<PathBuf> {
find_on_path("opencode").or_else(|| {
dirs::home_dir().and_then(|h| {
let p = h.join(".opencode").join("bin").join("opencode");
p.exists().then_some(p)
})
})
}
fn opencode_config(
server: &str,
model: &str,
api_key: &str,
variants: &[(&'static str, serde_json::Value)],
) -> String {
use serde::ser::{SerializeMap, Serializer};
fn entries<S: Serializer, V: serde::Serialize>(
entries: &[(&str, V)],
serializer: S,
) -> Result<S::Ok, S::Error> {
let mut map = serializer.serialize_map(Some(entries.len()))?;
for (key, value) in entries {
map.serialize_entry(key, value)?;
}
map.end()
}
#[derive(serde::Serialize)]
struct Config<'a> {
#[serde(rename = "$schema")]
schema: &'static str,
provider: Providers<'a>,
model: String,
}
#[derive(serde::Serialize)]
struct Providers<'a> {
ollama: Provider<'a>,
}
#[derive(serde::Serialize)]
struct Provider<'a> {
npm: &'static str,
name: &'static str,
options: Options<'a>,
#[serde(serialize_with = "entries")]
models: [(&'a str, Model<'a>); 1],
}
#[derive(serde::Serialize)]
struct Options<'a> {
#[serde(rename = "baseURL")]
base_url: String,
#[serde(rename = "apiKey")]
api_key: &'a str,
}
#[derive(serde::Serialize)]
struct Model<'a> {
name: &'a str,
#[serde(serialize_with = "entries", skip_serializing_if = "<[_]>::is_empty")]
variants: &'a [(&'static str, serde_json::Value)],
}
let config = Config {
schema: "https://opencode.ai/config.json",
provider: Providers {
ollama: Provider {
npm: "@ai-sdk/openai-compatible",
name: "Ollama",
options: Options {
base_url: format!("{server}/v1"),
api_key,
},
models: [(
model,
Model {
name: model,
variants,
},
)],
},
},
model: format!("ollama/{model}"),
};
serde_json::to_string(&config).expect("opencode config serializes")
}
fn launch_codex(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
write_codex_config()?;
let bin = find_on_path("codex").ok_or_else(|| anyhow::anyhow!("codex is not installed"))?;
let mut args: Vec<String> = Vec::new();
if !model.is_empty() {
args.extend(["--model".to_string(), model.to_string()]);
}
args.extend(["--profile".to_string(), "llmman".to_string()]);
args.extend_from_slice(extra_args);
exec_with_env(&bin, &args, &[("OPENAI_API_KEY", api_key)])
}
fn write_codex_config() -> anyhow::Result<()> {
let home = dirs::home_dir().context("no home directory")?;
let config_dir = home.join(".codex");
std::fs::create_dir_all(&config_dir)?;
let config_path = config_dir.join("config.toml");
if let Ok(existing) = std::fs::read_to_string(&config_path) {
if existing.contains("[profiles.llmman]") {
std::fs::write(&config_path, strip_legacy_llmman_profile(&existing))?;
}
}
let profile_path = config_dir.join("llmman.config.toml");
let contents = codex_profile(&daemon::server());
if std::fs::read_to_string(&profile_path).ok().as_deref() != Some(contents.as_str()) {
std::fs::write(&profile_path, contents)?;
}
Ok(())
}
fn codex_profile(server: &str) -> String {
format!(
"# Written by `llmman launch codex`; edits are overwritten.\n\
model_provider = \"llmman\"\n\
\n\
[model_providers.llmman]\n\
name = \"llmman\"\n\
base_url = \"{server}/v1\"\n\
env_key = \"OPENAI_API_KEY\"\n\
wire_api = \"responses\"\n\
supports_websockets = false\n"
)
}
fn strip_legacy_llmman_profile(existing: &str) -> String {
let mut out = String::new();
let mut skipping = false;
for line in existing.lines() {
let trimmed = line.trim();
if trimmed == "[profiles.llmman]" {
skipping = true;
continue;
}
if skipping && trimmed.starts_with('[') {
skipping = false;
}
if skipping {
continue;
}
out.push_str(line);
out.push('\n');
}
out
}
fn launch_aider(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
let base_url = format!("{}/v1", daemon::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_copilot(model: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin =
find_on_path("gh").ok_or_else(|| anyhow::anyhow!("gh (GitHub CLI) is not installed"))?;
let base_url = format!("{}/v1", daemon::server());
let mut args = vec!["copilot".to_string()];
if !model.is_empty() {
args.extend(["--model".to_string(), model.to_string()]);
}
args.extend_from_slice(extra_args);
exec_with_env(&bin, &args, &[("COPILOT_PROVIDER_BASE_URL", &base_url)])
}
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", daemon::server());
exec_with_env(
&bin,
&args,
&[
("GEMINI_BASE_URL", base_url.as_str()),
("GEMINI_API_KEY", api_key),
],
)
}
fn launch_agy(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin = find_on_path("agy").ok_or_else(|| anyhow::anyhow!("agy is not installed"))?;
anyhow::ensure!(
!extra_args
.iter()
.any(|arg| matches!(arg.split('=').next(), Some("--gemini_dir" | "-gemini_dir"))),
"llmman manages AGY’s --gemini_dir"
);
let gemini_dir = agy_settings_dir()?;
write_agy_settings_at(&gemini_dir)?;
let mut args = vec![format!("--gemini_dir={}", gemini_dir.display())];
args.extend_from_slice(extra_args);
let encoded = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(model.as_bytes());
let base_url = format!("{}/gemini/{encoded}", daemon::server());
exec_with_env(
&bin,
&args,
&[
("GOOGLE_GEMINI_BASE_URL", base_url.as_str()),
("GEMINI_API_KEY", api_key),
("GOOGLE_API_KEY", api_key),
],
)
}
fn agy_settings_dir() -> anyhow::Result<PathBuf> {
Ok(dirs::home_dir()
.context("no home directory")?
.join(".gemini")
.join("llmman"))
}
fn write_agy_settings_at(gemini_dir: &Path) -> anyhow::Result<()> {
let settings_path = gemini_dir.join("antigravity-cli").join("settings.json");
std::fs::create_dir_all(settings_path.parent().expect("settings file has a parent"))?;
crate::fsutil::write_atomic(&settings_path, b"{\n \"modelProvider\": \"gemini\"\n}\n")
.with_context(|| format!("write {}", settings_path.display()))
}
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 = daemon::server();
exec_with_env(&bin, extra_args, &[("OLLAMA_HOST", server.as_str())])
}
fn launch_hermes(model: &str, 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 })?;
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) -> 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 model = yaml_quote(model);
let base_url = yaml_quote(&format!("{}/v1", daemon::server()));
let ours = format!(
"model:\n provider: llmman\n default: {model}\n base_url: {base_url}\n api_key: llmman\n\
providers:\n llmman:\n name: llmman\n api: {base_url}\n default_model: {model}\n models:\n - {model}\n"
);
std::fs::write(&config_path, format!("{preserved}{ours}"))?;
Ok(())
}
fn yaml_quote(s: &str) -> String {
format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\""))
}
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 openclaw_model_id(model: &str) -> &str {
let bare = model.strip_prefix("docker.io/ai/").unwrap_or(model);
if bare.is_empty() {
"default"
} else {
bare
}
}
fn launch_openclaw(model: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin =
find_on_path("openclaw").ok_or_else(|| anyhow::anyhow!("openclaw is not installed"))?;
let onboarded = dirs::home_dir().is_some_and(|h| {
h.join(".openclaw").join("openclaw.json").exists()
|| h.join(".clawdbot").join("clawdbot.json").exists()
});
if !onboarded {
let effective_model = openclaw_model_id(model);
let status = Command::new(&bin)
.args([
"onboard",
"--non-interactive",
"--accept-risk",
"--auth-choice",
"ollama",
"--custom-base-url",
&format!("{}/v1", daemon::server()),
"--custom-model-id",
effective_model,
"--skip-health",
"--skip-channels",
"--skip-skills",
])
.status()
.with_context(|| format!("failed to run {}", bin.display()))?;
anyhow::ensure!(status.success(), "openclaw onboarding failed");
}
exec_with_env(&bin, extra_args, &[])
}
fn launch_qwen(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin = find_qwen().ok_or_else(|| anyhow::anyhow!("qwen is not installed"))?;
let model = forwarded_model(extra_args).unwrap_or(model);
write_qwen_settings(model)?;
let base_url = format!("{}/v1", daemon::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 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 forwarded_model(extra_args: &[String]) -> Option<&str> {
let mut found = None;
let mut args = extra_args.iter().map(String::as_str);
while let Some(a) = args.next() {
match a {
"--model" | "-m" => found = args.next().or(found),
_ => {
if let Some(v) = a.strip_prefix("--model=").or_else(|| a.strip_prefix("-m=")) {
found = Some(v);
}
}
}
}
found.filter(|v| !v.is_empty())
}
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(expand_tilde(&dir, &home()?)),
None => Ok(home()?.join(".qwen")),
}
}
fn expand_tilde(dir: &str, home: &Path) -> PathBuf {
match dir.strip_prefix('~') {
Some(rest) if rest.is_empty() || rest.starts_with(['/', '\\']) => {
home.join(rest.trim_start_matches(['/', '\\']))
}
_ => PathBuf::from(dir),
}
}
fn write_qwen_settings(model: &str) -> anyhow::Result<()> {
write_qwen_settings_at(&qwen_home()?, model, &format!("{}/v1", daemon::server()))
}
fn write_qwen_settings_at(dir: &Path, model: &str, base_url: &str) -> anyhow::Result<()> {
let path = dir.join("settings.json");
let raw = match std::fs::read_to_string(&path) {
Ok(raw) => Some(raw),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
Err(e) => return Err(e).with_context(|| format!("read {}", path.display())),
};
let existing = match raw.as_deref().map(str::trim) {
None | Some("") => serde_json::json!({}),
Some(text) => match serde_json::from_str::<serde_json::Value>(&strip_json_comments(text)) {
Ok(value) if value.is_object() => value,
_ => {
eprintln!(
"[llmman] qwen: {} is not a JSON object; leaving it alone",
path.display()
);
return Ok(());
}
},
};
let merged = qwen_settings_merged(&existing, model, base_url);
if merged == existing {
return Ok(());
}
std::fs::create_dir_all(dir).with_context(|| format!("create {}", dir.display()))?;
if let Some(raw) = &raw {
let bak = path.with_extension("json.bak");
if !bak.exists() || strip_json_comments(raw) != *raw {
std::fs::copy(&path, &bak)
.with_context(|| format!("back up {} to {}", path.display(), bak.display()))?;
}
}
let mut out = serde_json::to_string_pretty(&merged)?;
out.push('\n');
crate::fsutil::write_atomic(&path, out.as_bytes())
.with_context(|| format!("write {}", path.display()))
}
fn strip_json_comments(raw: &str) -> String {
let mut out = String::with_capacity(raw.len());
let mut chars = raw.chars().peekable();
let mut in_string = false;
let mut escaped = false;
while let Some(c) = chars.next() {
if in_string {
out.push(c);
if escaped {
escaped = false;
} else if c == '\\' {
escaped = true;
} else if c == '"' {
in_string = false;
}
continue;
}
match c {
'"' => {
in_string = true;
out.push(c);
}
'/' if chars.peek() == Some(&'/') => {
out.push(' ');
while chars.peek().is_some_and(|&n| n != '\n') {
chars.next();
out.push(' ');
}
}
'/' if chars.peek() == Some(&'*') => {
chars.next();
out.push_str(" ");
let mut prev = ' ';
for n in chars.by_ref() {
out.push(if n == '\n' { '\n' } else { ' ' });
if prev == '*' && n == '/' {
break;
}
prev = n;
}
}
_ => out.push(c),
}
}
out
}
const QWEN_ENV_KEY: &str = "LLMMAN_API_KEY";
fn qwen_settings_merged(
existing: &serde_json::Value,
model: &str,
base_url: &str,
) -> serde_json::Value {
let mut doc = existing.as_object().cloned().unwrap_or_default();
let ours = serde_json::json!({
"id": model,
"name": format!("{model} (llmman)"),
"baseUrl": base_url,
"envKey": QWEN_ENV_KEY,
});
let openai = 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 = object_under(object_under(&mut doc, "security"), "auth");
auth.insert("selectedType".into(), "openai".into());
auth.insert("baseUrl".into(), base_url.into());
let model_cfg = object_under(&mut doc, "model");
model_cfg.insert("name".into(), model.into());
model_cfg.insert("baseUrl".into(), base_url.into());
serde_json::Value::Object(doc)
}
fn object_under<'a>(
parent: &'a mut serde_json::Map<String, serde_json::Value>,
key: &str,
) -> &'a mut serde_json::Map<String, serde_json::Value> {
let slot = parent.entry(key).or_insert_with(|| serde_json::json!({}));
if !slot.is_object() {
*slot = serde_json::json!({});
}
slot.as_object_mut().expect("set to an object just above")
}
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_goose(model: &str, api_key: &str, extra_args: &[String]) -> anyhow::Result<()> {
let bin = find_goose().ok_or_else(|| anyhow::anyhow!("goose is not installed"))?;
let host = daemon::server();
exec_with_env(&bin, extra_args, &goose_env(model, api_key, &host))
}
fn goose_env<'a>(model: &'a str, api_key: &'a str, host: &'a str) -> Vec<(&'a str, &'a str)> {
let mut env = vec![
("GOOSE_PROVIDER", "openai"),
("OPENAI_API_KEY", api_key),
("OPENAI_HOST", host),
("OPENAI_BASE_PATH", "v1/chat/completions"),
];
if !model.is_empty() {
env.push(("GOOSE_MODEL", model));
}
env
}
fn find_goose() -> Option<PathBuf> {
find_on_path("goose").or_else(|| goose_fallback(&dirs::home_dir()?))
}
fn goose_fallback(home: &Path) -> Option<PathBuf> {
let bin = if cfg!(windows) { "goose.exe" } else { "goose" };
let mut candidates = Vec::new();
if cfg!(windows) {
candidates.push(home.join("goose").join(bin));
}
candidates.push(home.join(".local").join("bin").join(bin));
candidates.into_iter().find(|p| p.is_file())
}
const DSH_API_KEY_ENV: &str = "LLMMAN_API_KEY";
fn launch_dsh(
model: &str,
api_key: &str,
vision: bool,
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)?;
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) -> anyhow::Result<()> {
let quoted_model = yaml_quote(model);
let base_url = yaml_quote(&format!("{}/v1", daemon::server()));
let input = if vision { "[text, image]" } else { "[text]" };
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 \
models:\n - id: {quoted_model}\n name: {quoted_model}\n input: {input}\n"
);
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 = 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()))
}
fn exec_with_env(bin: &PathBuf, args: &[String], extra_env: &[(&str, &str)]) -> anyhow::Result<()> {
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());
let mut env: std::collections::HashMap<String, String> = std::env::vars().collect();
env.insert("OLLAMA_HOST".to_string(), daemon::server());
for (k, v) in extra_env {
env.insert(k.to_string(), v.to_string());
}
cmd.envs(&env);
let status = cmd
.status()
.with_context(|| format!("failed to run {}", bin.display()))?;
std::process::exit(status.code().unwrap_or(1));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn agy_settings_are_written_to_the_llmman_owned_directory() {
let dir = std::env::temp_dir().join(format!(
"llmman-agy-settings-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
write_agy_settings_at(&dir).unwrap();
assert_eq!(
std::fs::read_to_string(dir.join("antigravity-cli/settings.json")).unwrap(),
"{\n \"modelProvider\": \"gemini\"\n}\n"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[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 yaml_quote_escapes_keywords_and_metacharacters() {
assert_eq!(yaml_quote("qwen3.5:0.8b"), "\"qwen3.5:0.8b\"");
assert_eq!(yaml_quote("null"), "\"null\"");
assert_eq!(yaml_quote("true"), "\"true\"");
assert_eq!(
yaml_quote(r#"a "quoted" \ value"#),
r#""a \"quoted\" \\ value""#
);
}
#[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 openclaw_model_id_strips_the_docker_ai_prefix() {
assert_eq!(
openclaw_model_id("docker.io/ai/qwen3.5:0.8b"),
"qwen3.5:0.8b"
);
assert_eq!(openclaw_model_id("qwen3.5:0.8b"), "qwen3.5:0.8b");
assert_eq!(
openclaw_model_id("hf.co/unsloth/Qwen3.5-0.8B-GGUF"),
"hf.co/unsloth/Qwen3.5-0.8B-GGUF"
);
assert_eq!(openclaw_model_id(""), "default");
assert_eq!(openclaw_model_id("docker.io/ai/"), "default");
}
#[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 goose_env_points_at_the_daemon_and_carries_the_key() {
let env = goose_env("m", "k", "http://127.0.0.1:17434");
let get = |k| env.iter().find(|(n, _)| *n == k).map(|(_, v)| *v);
assert_eq!(get("GOOSE_PROVIDER"), Some("openai"));
assert_eq!(get("GOOSE_MODEL"), Some("m"));
assert_eq!(get("OPENAI_API_KEY"), Some("k"));
assert_eq!(get("OPENAI_HOST"), Some("http://127.0.0.1:17434"));
assert_eq!(get("OPENAI_BASE_PATH"), Some("v1/chat/completions"));
let env = goose_env("", "k", "http://127.0.0.1:17434");
assert!(!env.iter().any(|(n, _)| *n == "GOOSE_MODEL"));
}
#[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 goose_fallback_finds_the_installers_target() {
let name = if cfg!(windows) { "goose.exe" } else { "goose" };
let dirs: &[&[&str]] = if cfg!(windows) {
&[&["goose"], &[".local", "bin"]]
} else {
&[&[".local", "bin"]]
};
for (i, parts) in dirs.iter().enumerate() {
let home = std::env::temp_dir().join(format!(
"llmman-goose-{}-{}-{i}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let bin = parts.iter().fold(home.clone(), |p, part| p.join(part));
std::fs::create_dir_all(&bin).unwrap();
assert_eq!(goose_fallback(&home), None);
let goose = bin.join(name);
std::fs::create_dir(&goose).unwrap();
assert_eq!(goose_fallback(&home), None);
std::fs::remove_dir(&goose).unwrap();
std::fs::write(&goose, "").unwrap();
assert_eq!(goose_fallback(&home), Some(goose));
assert_eq!(goose_fallback(&home.join("nowhere")), None);
let _ = std::fs::remove_dir_all(&home);
}
}
#[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 forwarded_model_takes_the_last_spelling() {
let args = |a: &[&str]| a.iter().map(|s| s.to_string()).collect::<Vec<_>>();
assert_eq!(forwarded_model(&args(&["--model", "b"])), Some("b"));
assert_eq!(forwarded_model(&args(&["-m=b", "--model", "c"])), Some("c"));
assert_eq!(forwarded_model(&args(&["--model=b", "-m", "c"])), Some("c"));
assert_eq!(forwarded_model(&args(&["-p", "x"])), None);
assert_eq!(forwarded_model(&args(&["--model"])), None);
assert_eq!(forwarded_model(&args(&["--model="])), None);
}
#[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);
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);
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), once);
let text = once.to_string();
assert!(!text.contains("apiKey") && !text.contains("\"env\""));
assert!(!PROVIDER_NEEDS_DAEMON_KEY.contains(&"qwen"));
}
#[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");
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");
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");
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 strip_json_comments_keeps_strings_and_columns() {
let raw =
"{\n // note\n \"url\": \"http://h//v1\", /* block\n */ \"q\": \"a\\\"//b\"\n}\n";
let stripped = strip_json_comments(raw);
assert_eq!(stripped.chars().count(), raw.chars().count());
assert_eq!(stripped.lines().count(), raw.lines().count());
let v: serde_json::Value = serde_json::from_str(&stripped).unwrap();
assert_eq!(v["url"], "http://h//v1");
assert_eq!(v["q"], "a\"//b");
assert_eq!(strip_json_comments("{\"a\": 1}"), "{\"a\": 1}");
}
#[test]
fn expand_tilde_reads_the_forms_qwen_code_reads() {
let home = Path::new("/h");
assert_eq!(expand_tilde("~/alt", home), PathBuf::from("/h/alt"));
assert_eq!(expand_tilde("~", home), PathBuf::from("/h"));
assert_eq!(expand_tilde("/abs", home), PathBuf::from("/abs"));
assert_eq!(expand_tilde("~user/x", home), PathBuf::from("~user/x"));
}
#[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).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).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).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).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).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).unwrap();
assert_eq!(read()["model"]["name"], "m:latest");
std::fs::write(&path, "{ not json").unwrap();
write_qwen_settings_at(&dir, "m:latest", url).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).unwrap();
assert_eq!(std::fs::read_to_string(&path).unwrap(), "[]");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn strip_legacy_llmman_profile_removes_only_that_table() {
let existing = "\
[some_other_setting]
foo = \"bar\"
[profiles.llmman]
openai_base_url = \"http://127.0.0.1:17434/v1\"
[profiles.other]
model = \"gpt-5\"
";
let cleaned = strip_legacy_llmman_profile(existing);
assert!(!cleaned.contains("[profiles.llmman]"));
assert!(!cleaned.contains("openai_base_url"));
assert!(cleaned.contains("[some_other_setting]"));
assert!(cleaned.contains("foo = \"bar\""));
assert!(cleaned.contains("[profiles.other]"));
assert!(cleaned.contains("model = \"gpt-5\""));
}
#[test]
fn strip_legacy_llmman_profile_is_a_no_op_without_the_legacy_table() {
let existing = "[profiles.other]\nmodel = \"gpt-5\"\n";
assert_eq!(strip_legacy_llmman_profile(existing), existing);
}
#[test]
fn strip_legacy_llmman_profile_handles_the_table_at_end_of_file() {
let existing = "[profiles.llmman]\nopenai_base_url = \"http://127.0.0.1:17434/v1\"\n";
assert_eq!(strip_legacy_llmman_profile(existing), "");
}
#[test]
fn opencode_config_lists_the_variants_in_order() {
let variants = opencode_variants(None);
let text = opencode_config("http://127.0.0.1:17434", "qwen3.5:0.8b", "k", &variants);
let config: serde_json::Value = serde_json::from_str(&text).expect("valid JSON");
assert_eq!(config["$schema"], "https://opencode.ai/config.json");
assert_eq!(config["model"], "ollama/qwen3.5:0.8b");
let provider = &config["provider"]["ollama"];
assert_eq!(provider["npm"], "@ai-sdk/openai-compatible");
assert_eq!(provider["name"], "Ollama");
assert_eq!(provider["options"]["baseURL"], "http://127.0.0.1:17434/v1");
assert_eq!(provider["options"]["apiKey"], "k");
assert_eq!(provider["models"].as_object().map(|m| m.len()), Some(1));
let model = &provider["models"]["qwen3.5:0.8b"];
assert_eq!(model["name"], "qwen3.5:0.8b");
let written = model["variants"].as_object().expect("variants object");
assert_eq!(written.len(), variants.len());
for (name, options) in &variants {
assert_eq!(&written[*name], options, "variant {name}");
}
let positions: Vec<usize> = variants
.iter()
.map(|(name, _)| text.find(&format!("\"{name}\"")).expect(name))
.collect();
assert!(positions.windows(2).all(|w| w[0] < w[1]), "{text}");
let bare = opencode_config("http://h", "m", "k", &[]);
assert!(!bare.contains("variants"), "{bare}");
}
#[test]
fn opencode_config_escapes_the_model_name() {
let model = "we\"ird/mo\\del";
let config: serde_json::Value =
serde_json::from_str(&opencode_config("http://h", model, "k", &[]))
.expect("valid JSON");
assert_eq!(config["model"], format!("ollama/{model}"));
assert_eq!(config["provider"]["ollama"]["models"][model]["name"], model);
}
#[test]
fn opencode_variants_follow_the_templates_controls() {
let gemma4 = ThinkingControls {
thinks: true,
enable_thinking: true,
efforts: vec![],
};
assert_eq!(
opencode_variants(Some(&gemma4)),
[
("none", serde_json::json!({ "reasoningEffort": "none" })),
(
"thinking",
serde_json::json!({ "chat_template_kwargs": { "enable_thinking": true } })
),
]
);
let qwen3_8 = ThinkingControls {
efforts: vec!["low", "xhigh"],
..gemma4
};
assert_eq!(
opencode_variants(Some(&qwen3_8)),
[
("none", serde_json::json!({ "reasoningEffort": "none" })),
("low", serde_json::json!({ "reasoningEffort": "low" })),
("xhigh", serde_json::json!({ "reasoningEffort": "xhigh" })),
]
);
assert!(opencode_variants(Some(&ThinkingControls::default())).is_empty());
let fallback = opencode_variants(None);
assert_eq!(fallback.len(), PORTABLE_THINKING_LEVELS.len());
assert_eq!(fallback[0].0, "none");
}
#[test]
fn codex_profile_is_a_websocket_free_provider_at_the_daemon() {
let profile: toml::Value = codex_profile("http://127.0.0.1:17434")
.parse()
.expect("valid TOML");
assert_eq!(profile["model_provider"].as_str(), Some("llmman"));
let provider = &profile["model_providers"]["llmman"];
assert_eq!(
provider["base_url"].as_str(),
Some("http://127.0.0.1:17434/v1")
);
assert_eq!(provider["env_key"].as_str(), Some("OPENAI_API_KEY"));
assert_eq!(provider["wire_api"].as_str(), Some("responses"));
assert_eq!(provider["supports_websockets"].as_bool(), Some(false));
assert!(
profile.get("openai_base_url").is_none(),
"the built-in openai provider is not the one in use"
);
}
#[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).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).unwrap();
assert!(std::fs::read_to_string(&path)
.unwrap()
.contains("input: [text, image]"));
write_dsh_settings(&path, "m", false).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: {}",
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, &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, &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, &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 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: {}"));
}
}