@gguf/claw 2026.2.9 → 2026.2.13

package/dist/{onboard-skills-BnAcpzfX.js → onboard-skills-BFxdI1Y1.js}

@@ -1,17 +1,18 @@
-import { C as buildAllowedModelSet, M as resolveAllowlistModelKey, N as resolveConfiguredModelRef, O as modelKey, S as resolveOpenClawAgentDir, T as buildModelAliasIndex, Tt as DEFAULT_PROVIDER, Y as VENICE_DEFAULT_MODEL_REF, _ as ensureAuthProfileStore, bt as CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, c as CHUTES_AUTHORIZE_ENDPOINT, d as parseOAuthCallbackInput, g as upsertAuthProfile, k as normalizeProviderId, l as exchangeChutesCodeForTokens, n as resolveAuthProfileOrder, nt as SYNTHETIC_DEFAULT_MODEL_REF, ot as getCustomProviderApiKey, p as listProfilesForProvider, pt as normalizeSecretInput, u as generateChutesPkce, ut as resolveEnvApiKey, wt as DEFAULT_MODEL } from "./auth-profiles-FJ3VY25a.js";
-import { t as formatCliCommand } from "./command-format-ayFsmwwz.js";
-import { c as escapeRegExp, g as resolveConfigDir, s as ensureDir, t as CONFIG_DIR, y as resolveUserPath } from "./utils-Dk86IbEs.js";
-import { t as runCommandWithTimeout } from "./exec-B8JKbXKW.js";
-import { a as resolveAgentModelPrimary, c as resolveDefaultAgentId, r as resolveAgentDir, s as resolveAgentWorkspaceDir, w as resolveDefaultAgentWorkspaceDir } from "./agent-scope-D3me2AZa.js";
-import { t as resolveBrewExecutable } from "./brew-BIrWdDps.js";
-import { Yt as loadModelCatalog, m as openUrl, o as detectBinary, y as resolveNodeManagerOptions } from "./loader-BnzQyT31.js";
-import { a as enablePluginInConfig } from "./onboard-channels-CtDnwaF5.js";
-import { t as scanDirectoryWithSummary } from "./skill-scanner-C_fQzVDu.js";
-import { B as fetchWithSsrFGuard } from "./deliver-CD7-BhYD.js";
-import { _ as resolveSkillKey, d as hasBinary, i as loadWorkspaceSkillEntries, t as resolveSkillsInstallPreferences } from "./skills-Ccsv3IQq.js";
-import { n as resolveWideAreaDiscoveryDomain } from "./widearea-dns-CMIG6-74.js";
-import { $ as setMinimaxApiKey, A as applyQianfanProviderConfig, B as applyXaiProviderConfig, C as applyMoonshotConfig, D as applyOpenrouterConfig, E as applyMoonshotProviderConfigCn, F as applyVeniceConfig, G as TOGETHER_DEFAULT_MODEL_REF, H as applyXiaomiProviderConfig, I as applyVeniceProviderConfig, J as ZAI_DEFAULT_MODEL_REF, K as VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, L as applyVercelAiGatewayConfig, M as applySyntheticProviderConfig, N as applyTogetherConfig, O as applyOpenrouterProviderConfig, P as applyTogetherProviderConfig, Q as setKimiCodingApiKey, R as applyVercelAiGatewayProviderConfig, S as applyKimiCodeProviderConfig, T as applyMoonshotProviderConfig, U as applyZaiConfig, V as applyXiaomiConfig, W as OPENROUTER_DEFAULT_MODEL_REF, X as setCloudflareAiGatewayConfig, Y as setAnthropicApiKey, Z as setGeminiApiKey, _ as applyMinimaxProviderConfig, _t as validateAnthropicSetupToken, at as setTogetherApiKey, b as applyCloudflareAiGatewayProviderConfig, ct as setXaiApiKey, d as resolvePluginProviders, dt as writeOAuthCredentials, et as setMoonshotApiKey, f as applyOpencodeZenConfig, ft as KIMI_CODING_MODEL_REF, g as applyMinimaxConfig, gt as buildTokenProfileId, h as applyMinimaxApiProviderConfig, ht as XAI_DEFAULT_MODEL_REF, i as formatTokenK, it as setSyntheticApiKey, j as applySyntheticConfig, k as applyQianfanConfig, l as createVpsAwareOAuthHandlers, lt as setXiaomiApiKey, m as applyMinimaxApiConfig, mt as QIANFAN_DEFAULT_MODEL_REF, nt as setOpenrouterApiKey, ot as setVeniceApiKey, p as applyOpencodeZenProviderConfig, pt as MOONSHOT_DEFAULT_MODEL_REF, q as XIAOMI_DEFAULT_MODEL_REF, rt as setQianfanApiKey, st as setVercelAiGatewayApiKey, t as githubCopilotLoginCommand, tt as setOpencodeZenApiKey, u as isRemoteEnvironment, ut as setZaiApiKey, v as applyAuthProfileConfig, w as applyMoonshotConfigCn, x as applyKimiCodeConfig, y as applyCloudflareAiGatewayConfig, z as applyXaiConfig } from "./github-copilot-auth-CQIWc0hC.js";
-import { t as buildWorkspaceSkillStatus } from "./skills-status-Cp2ZFhIx.js";
+import { A as normalizeProviderId, At as DEFAULT_MODEL, C as resolveOpenClawAgentDir, E as buildModelAliasIndex, Et as CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, N as resolveAllowlistModelKey, P as resolveConfiguredModelRef, Tt as isHuggingfacePolicyLocked, X as VENICE_DEFAULT_MODEL_REF, _ as upsertAuthProfileWithLock, c as CHUTES_AUTHORIZE_ENDPOINT, d as parseOAuthCallbackInput, dt as resolveEnvApiKey, g as upsertAuthProfile, jt as DEFAULT_PROVIDER, k as modelKey, l as exchangeChutesCodeForTokens, mt as normalizeSecretInput, n as resolveAuthProfileOrder, p as listProfilesForProvider, rt as SYNTHETIC_DEFAULT_MODEL_REF, st as getCustomProviderApiKey, u as generateChutesPkce, v as ensureAuthProfileStore, w as buildAllowedModelSet, wt as discoverHuggingfaceModels } from "./auth-profiles-Cp9MtUdM.js";
+import { t as formatCliCommand } from "./command-format-Bxe0mWee.js";
+import { c as escapeRegExp, g as resolveConfigDir, s as ensureDir, t as CONFIG_DIR, y as resolveUserPath } from "./utils-BLJAc3ZV.js";
+import { t as runCommandWithTimeout } from "./exec-DqZFMawz.js";
+import { a as resolveAgentModelPrimary, c as resolveDefaultAgentId, r as resolveAgentDir, s as resolveAgentWorkspaceDir, w as resolveDefaultAgentWorkspaceDir } from "./agent-scope-Bkr9fZtl.js";
+import { t as resolveBrewExecutable } from "./brew-DlQQMJ3n.js";
+import { m as openUrl, o as detectBinary, y as resolveNodeManagerOptions } from "./loader-CS-5lMQa.js";
+import { a as enablePluginInConfig } from "./onboard-channels-C5uL3i8d.js";
+import { t as scanDirectoryWithSummary } from "./skill-scanner-BrGkh5K7.js";
+import { a as fetchWithTimeout, r as fetchWithSsrFGuard } from "./fetch-wuOZDzdT.js";
+import { h as hasBinary, i as loadWorkspaceSkillEntries, t as resolveSkillsInstallPreferences, x as resolveSkillKey } from "./skills-CE7by2IF.js";
+import { _ as loadModelCatalog } from "./runner-BEy5ZGFv.js";
+import { n as resolveWideAreaDiscoveryDomain } from "./widearea-dns-C4RnIR9O.js";
+import { $ as VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, A as applyQianfanProviderConfig, At as validateAnthropicSetupToken, B as applyXiaomiProviderConfig, C as applyMoonshotConfig, Ct as QIANFAN_DEFAULT_MODEL_REF, D as applyOpenrouterConfig, Dt as ZAI_CODING_GLOBAL_BASE_URL, E as applyMoonshotProviderConfigCn, Et as ZAI_CODING_CN_BASE_URL, F as applyVeniceConfig, G as applyCloudflareAiGatewayConfig, H as applyZaiProviderConfig, I as applyVeniceProviderConfig, J as applyVercelAiGatewayProviderConfig, K as applyCloudflareAiGatewayProviderConfig, L as applyXaiConfig, M as applySyntheticProviderConfig, N as applyTogetherConfig, O as applyOpenrouterProviderConfig, Ot as ZAI_GLOBAL_BASE_URL, P as applyTogetherProviderConfig, Q as TOGETHER_DEFAULT_MODEL_REF, R as applyXaiProviderConfig, S as applyKimiCodeProviderConfig, St as MOONSHOT_DEFAULT_MODEL_REF, T as applyMoonshotProviderConfig, Tt as ZAI_CN_BASE_URL, U as applyLitellmConfig, V as applyZaiConfig, W as applyLitellmProviderConfig, X as LITELLM_DEFAULT_MODEL_REF, Y as HUGGINGFACE_DEFAULT_MODEL_REF, Z as OPENROUTER_DEFAULT_MODEL_REF, _ as applyMinimaxProviderConfig, _t as setXaiApiKey, a as normalizeAlias, at as setHuggingfaceApiKey, b as applyHuggingfaceProviderConfig, bt as writeOAuthCredentials, ct as setMinimaxApiKey, d as resolvePluginProviders, dt as setOpenrouterApiKey, et as XIAOMI_DEFAULT_MODEL_REF, f as applyOpencodeZenConfig, ft as setQianfanApiKey, g as applyMinimaxConfig, gt as setVercelAiGatewayApiKey, h as applyMinimaxApiProviderConfig, ht as setVeniceApiKey, i as formatTokenK, it as setGeminiApiKey, j as applySyntheticConfig, k as applyQianfanConfig, kt as buildTokenProfileId, l as createVpsAwareOAuthHandlers, lt as setMoonshotApiKey, m as applyMinimaxApiConfig, mt as setTogetherApiKey, nt as setAnthropicApiKey, ot as setKimiCodingApiKey, p as applyOpencodeZenProviderConfig, pt as setSyntheticApiKey, q as applyVercelAiGatewayConfig, rt as setCloudflareAiGatewayConfig, st as setLitellmApiKey, t as githubCopilotLoginCommand, tt as ZAI_DEFAULT_MODEL_REF, u as isRemoteEnvironment, ut as setOpencodeZenApiKey, v as applyAuthProfileConfig, vt as setXiaomiApiKey, w as applyMoonshotConfigCn, wt as XAI_DEFAULT_MODEL_REF, x as applyKimiCodeConfig, xt as KIMI_CODING_MODEL_REF, yt as setZaiApiKey, z as applyXiaomiConfig } from "./github-copilot-auth-BUqfX7hG.js";
+import { t as buildWorkspaceSkillStatus } from "./skills-status-B99Us6yS.js";
 import path from "node:path";
 import fs from "node:fs";
 import { loginOpenAICodex } from "@mariozechner/pi-ai";
@@ -415,10 +416,16 @@ const AUTH_CHOICE_GROUP_DEFS = [
 		hint: "setup-token + API key",
 		choices: ["token", "apiKey"]
 	},
+	{
+		value: "vllm",
+		label: "vLLM",
+		hint: "Local/self-hosted OpenAI-compatible",
+		choices: ["vllm"]
+	},
 	{
 		value: "minimax",
 		label: "MiniMax",
-		hint: "M2.1 (recommended)",
+		hint: "M2.5 (recommended)",
 		choices: [
 			"minimax-portal",
 			"minimax-api",
@@ -465,9 +472,14 @@ const AUTH_CHOICE_GROUP_DEFS = [
 	},
 	{
 		value: "zai",
-		label: "Z.AI (GLM 4.7)",
-		hint: "API key",
-		choices: ["zai-api-key"]
+		label: "Z.AI",
+		hint: "GLM Coding Plan / Global / CN",
+		choices: [
+			"zai-coding-global",
+			"zai-coding-cn",
+			"zai-global",
+			"zai-cn"
+		]
 	},
 	{
 		value: "qianfan",
@@ -511,17 +523,35 @@ const AUTH_CHOICE_GROUP_DEFS = [
 		hint: "API key",
 		choices: ["together-api-key"]
 	},
+	{
+		value: "huggingface",
+		label: "Hugging Face",
+		hint: "Inference API (HF token)",
+		choices: ["huggingface-api-key"]
+	},
 	{
 		value: "venice",
 		label: "Venice AI",
 		hint: "Privacy-focused (uncensored models)",
 		choices: ["venice-api-key"]
 	},
+	{
+		value: "litellm",
+		label: "LiteLLM",
+		hint: "Unified LLM gateway (100+ providers)",
+		choices: ["litellm-api-key"]
+	},
 	{
 		value: "cloudflare-ai-gateway",
 		label: "Cloudflare AI Gateway",
 		hint: "Account ID + Gateway ID + API key",
 		choices: ["cloudflare-ai-gateway-api-key"]
+	},
+	{
+		value: "custom",
+		label: "Custom Provider",
+		hint: "Any OpenAI or Anthropic compatible endpoint",
+		choices: ["custom-api-key"]
 	}
 ];
 function buildAuthChoiceOptions(params) {
@@ -540,6 +570,11 @@ function buildAuthChoiceOptions(params) {
 		value: "chutes",
 		label: "Chutes (OAuth)"
 	});
+	options.push({
+		value: "vllm",
+		label: "vLLM (custom URL + model)",
+		hint: "Local/self-hosted OpenAI-compatible server"
+	});
 	options.push({
 		value: "openai-api-key",
 		label: "OpenAI API key"
@@ -556,6 +591,11 @@ function buildAuthChoiceOptions(params) {
 		value: "openrouter-api-key",
 		label: "OpenRouter API key"
 	});
+	options.push({
+		value: "litellm-api-key",
+		label: "LiteLLM API key",
+		hint: "Unified gateway for 100+ LLM providers"
+	});
 	options.push({
 		value: "ai-gateway-api-key",
 		label: "Vercel AI Gateway API key"
@@ -591,6 +631,11 @@ function buildAuthChoiceOptions(params) {
 		label: "Together AI API key",
 		hint: "Access to Llama, DeepSeek, Qwen, and more open models"
 	});
+	options.push({
+		value: "huggingface-api-key",
+		label: "Hugging Face API key (HF token)",
+		hint: "Inference Providers — OpenAI-compatible chat"
+	});
 	options.push({
 		value: "github-copilot",
 		label: "GitHub Copilot (GitHub device login)",
@@ -612,7 +657,27 @@ function buildAuthChoiceOptions(params) {
 	});
 	options.push({
 		value: "zai-api-key",
-		label: "Z.AI (GLM 4.7) API key"
+		label: "Z.AI API key"
+	});
+	options.push({
+		value: "zai-coding-global",
+		label: "Coding-Plan-Global",
+		hint: "GLM Coding Plan Global (api.z.ai)"
+	});
+	options.push({
+		value: "zai-coding-cn",
+		label: "Coding-Plan-CN",
+		hint: "GLM Coding Plan CN (open.bigmodel.cn)"
+	});
+	options.push({
+		value: "zai-global",
+		label: "Global",
+		hint: "Z.AI Global (api.z.ai)"
+	});
+	options.push({
+		value: "zai-cn",
+		label: "CN",
+		hint: "Z.AI CN (open.bigmodel.cn)"
 	});
 	options.push({
 		value: "xiaomi-api-key",
@@ -643,13 +708,17 @@ function buildAuthChoiceOptions(params) {
 	});
 	options.push({
 		value: "minimax-api",
-		label: "MiniMax M2.1"
+		label: "MiniMax M2.5"
 	});
 	options.push({
 		value: "minimax-api-lightning",
-		label: "MiniMax M2.1 Lightning",
+		label: "MiniMax M2.5 Lightning",
 		hint: "Faster, higher output cost"
 	});
+	options.push({
+		value: "custom-api-key",
+		label: "Custom Provider"
+	});
 	if (params.includeSkip) options.push({
 		value: "skip",
 		label: "Skip for now"
@@ -696,6 +765,7 @@ async function promptAuthChoiceGrouped(params) {
 			await params.prompter.note("No auth methods available for that provider.", "Model/auth choice");
 			continue;
 		}
+		if (group.options.length === 1) return group.options[0].value;
 		const methodSelection = await params.prompter.select({
 			message: `${group.label} auth method`,
 			options: [...group.options, {
@@ -747,7 +817,7 @@ async function applyAuthChoiceAnthropic(params) {
 			message: "Paste Anthropic setup-token",
 			validate: (value) => validateAnthropicSetupToken(String(value ?? ""))
 		});
-		const token = String(tokenRaw).trim();
+		const token = String(tokenRaw ?? "").trim();
 		const profileNameRaw = await params.prompter.text({
 			message: "Token name (blank = default)",
 			placeholder: "default"
@@ -796,7 +866,7 @@ async function applyAuthChoiceAnthropic(params) {
 				message: "Enter Anthropic API key",
 				validate: validateApiKeyInput
 			});
-			await setAnthropicApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setAnthropicApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "anthropic:default",
@@ -849,6 +919,189 @@ async function applyDefaultModelChoice(params) {
 	};
 }
 
+//#endregion
+//#region src/commands/auth-choice.apply.huggingface.ts
+async function applyAuthChoiceHuggingface(params) {
+	if (params.authChoice !== "huggingface-api-key") return null;
+	let nextConfig = params.config;
+	let agentModelOverride;
+	const noteAgentModel = async (model) => {
+		if (!params.agentId) return;
+		await params.prompter.note(`Default model set to ${model} for agent "${params.agentId}".`, "Model configured");
+	};
+	let hasCredential = false;
+	let hfKey = "";
+	if (!hasCredential && params.opts?.token && params.opts.tokenProvider === "huggingface") {
+		hfKey = normalizeApiKeyInput(params.opts.token);
+		await setHuggingfaceApiKey(hfKey, params.agentDir);
+		hasCredential = true;
+	}
+	if (!hasCredential) await params.prompter.note(["Hugging Face Inference Providers offer OpenAI-compatible chat completions.", "Create a token at: https://huggingface.co/settings/tokens (fine-grained, 'Make calls to Inference Providers')."].join("\n"), "Hugging Face");
+	if (!hasCredential) {
+		const envKey = resolveEnvApiKey("huggingface");
+		if (envKey) {
+			if (await params.prompter.confirm({
+				message: `Use existing Hugging Face token (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+				initialValue: true
+			})) {
+				hfKey = envKey.apiKey;
+				await setHuggingfaceApiKey(hfKey, params.agentDir);
+				hasCredential = true;
+			}
+		}
+	}
+	if (!hasCredential) {
+		const key = await params.prompter.text({
+			message: "Enter Hugging Face API key (HF token)",
+			validate: validateApiKeyInput
+		});
+		hfKey = normalizeApiKeyInput(String(key ?? ""));
+		await setHuggingfaceApiKey(hfKey, params.agentDir);
+	}
+	nextConfig = applyAuthProfileConfig(nextConfig, {
+		profileId: "huggingface:default",
+		provider: "huggingface",
+		mode: "api_key"
+	});
+	const models = await discoverHuggingfaceModels(hfKey);
+	const modelRefPrefix = "huggingface/";
+	const options = [];
+	for (const m of models) {
+		const baseRef = `${modelRefPrefix}${m.id}`;
+		const label = m.name ?? m.id;
+		options.push({
+			value: baseRef,
+			label
+		});
+		options.push({
+			value: `${baseRef}:cheapest`,
+			label: `${label} (cheapest)`
+		});
+		options.push({
+			value: `${baseRef}:fastest`,
+			label: `${label} (fastest)`
+		});
+	}
+	const defaultRef = HUGGINGFACE_DEFAULT_MODEL_REF;
+	options.sort((a, b) => {
+		if (a.value === defaultRef) return -1;
+		if (b.value === defaultRef) return 1;
+		return a.label.localeCompare(b.label, void 0, { sensitivity: "base" });
+	});
+	const selectedModelRef = options.length === 0 ? defaultRef : options.length === 1 ? options[0].value : await params.prompter.select({
+		message: "Default Hugging Face model",
+		options,
+		initialValue: options.some((o) => o.value === defaultRef) ? defaultRef : options[0].value
+	});
+	if (isHuggingfacePolicyLocked(selectedModelRef)) await params.prompter.note("Provider locked — router will choose backend by cost or speed.", "Hugging Face");
+	const applied = await applyDefaultModelChoice({
+		config: nextConfig,
+		setDefaultModel: params.setDefaultModel,
+		defaultModel: selectedModelRef,
+		applyDefaultConfig: (config) => {
+			const withProvider = applyHuggingfaceProviderConfig(config);
+			const existingModel = withProvider.agents?.defaults?.model;
+			return ensureModelAllowlistEntry({
+				cfg: {
+					...withProvider,
+					agents: {
+						...withProvider.agents,
+						defaults: {
+							...withProvider.agents?.defaults,
+							model: {
+								...existingModel && typeof existingModel === "object" && "fallbacks" in existingModel ? { fallbacks: existingModel.fallbacks } : {},
+								primary: selectedModelRef
+							}
+						}
+					}
+				},
+				modelRef: selectedModelRef
+			});
+		},
+		applyProviderConfig: applyHuggingfaceProviderConfig,
+		noteDefault: selectedModelRef,
+		noteAgentModel,
+		prompter: params.prompter
+	});
+	nextConfig = applied.config;
+	agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+	return {
+		config: nextConfig,
+		agentModelOverride
+	};
+}
+
+//#endregion
+//#region src/commands/auth-choice.apply.openrouter.ts
+async function applyAuthChoiceOpenRouter(params) {
+	let nextConfig = params.config;
+	let agentModelOverride;
+	const noteAgentModel = async (model) => {
+		if (!params.agentId) return;
+		await params.prompter.note(`Default model set to ${model} for agent "${params.agentId}".`, "Model configured");
+	};
+	const store = ensureAuthProfileStore(params.agentDir, { allowKeychainPrompt: false });
+	const existingProfileId = resolveAuthProfileOrder({
+		cfg: nextConfig,
+		store,
+		provider: "openrouter"
+	}).find((profileId) => Boolean(store.profiles[profileId]));
+	const existingCred = existingProfileId ? store.profiles[existingProfileId] : void 0;
+	let profileId = "openrouter:default";
+	let mode = "api_key";
+	let hasCredential = false;
+	if (existingProfileId && existingCred?.type) {
+		profileId = existingProfileId;
+		mode = existingCred.type === "oauth" ? "oauth" : existingCred.type === "token" ? "token" : "api_key";
+		hasCredential = true;
+	}
+	if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "openrouter") {
+		await setOpenrouterApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+		hasCredential = true;
+	}
+	if (!hasCredential) {
+		const envKey = resolveEnvApiKey("openrouter");
+		if (envKey) {
+			if (await params.prompter.confirm({
+				message: `Use existing OPENROUTER_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+				initialValue: true
+			})) {
+				await setOpenrouterApiKey(envKey.apiKey, params.agentDir);
+				hasCredential = true;
+			}
+		}
+	}
+	if (!hasCredential) {
+		const key = await params.prompter.text({
+			message: "Enter OpenRouter API key",
+			validate: validateApiKeyInput
+		});
+		await setOpenrouterApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
+		hasCredential = true;
+	}
+	if (hasCredential) nextConfig = applyAuthProfileConfig(nextConfig, {
+		profileId,
+		provider: "openrouter",
+		mode
+	});
+	const applied = await applyDefaultModelChoice({
+		config: nextConfig,
+		setDefaultModel: params.setDefaultModel,
+		defaultModel: OPENROUTER_DEFAULT_MODEL_REF,
+		applyDefaultConfig: applyOpenrouterConfig,
+		applyProviderConfig: applyOpenrouterProviderConfig,
+		noteDefault: OPENROUTER_DEFAULT_MODEL_REF,
+		noteAgentModel,
+		prompter: params.prompter
+	});
+	nextConfig = applied.config;
+	agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+	return {
+		config: nextConfig,
+		agentModelOverride
+	};
+}
+
 //#endregion
 //#region src/commands/google-gemini-model-default.ts
 const GOOGLE_GEMINI_DEFAULT_MODEL = "google/gemini-3-pro-preview";
@@ -883,6 +1136,91 @@ function applyGoogleGeminiModelDefault(cfg) {
 //#region src/commands/opencode-zen-model-default.ts
 const OPENCODE_ZEN_DEFAULT_MODEL = "opencode/claude-opus-4-6";
 
+//#endregion
+//#region src/commands/zai-endpoint-detect.ts
+async function probeZaiChatCompletions(params) {
+	try {
+		const res = await fetchWithTimeout(`${params.baseUrl}/chat/completions`, {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${params.apiKey}`,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify({
+				model: params.modelId,
+				stream: false,
+				max_tokens: 1,
+				messages: [{
+					role: "user",
+					content: "ping"
+				}]
+			})
+		}, params.timeoutMs, params.fetchFn);
+		if (res.ok) return { ok: true };
+		let errorCode;
+		let errorMessage;
+		try {
+			const json = await res.json();
+			const code = json?.error?.code;
+			const msg = json?.error?.message ?? json?.msg ?? json?.message;
+			if (typeof code === "string") errorCode = code;
+			else if (typeof code === "number") errorCode = String(code);
+			if (typeof msg === "string") errorMessage = msg;
+		} catch {}
+		return {
+			ok: false,
+			status: res.status,
+			errorCode,
+			errorMessage
+		};
+	} catch {
+		return { ok: false };
+	}
+}
+async function detectZaiEndpoint(params) {
+	if (process.env.VITEST && !params.fetchFn) return null;
+	const timeoutMs = params.timeoutMs ?? 5e3;
+	const glm5 = [{
+		endpoint: "global",
+		baseUrl: ZAI_GLOBAL_BASE_URL
+	}, {
+		endpoint: "cn",
+		baseUrl: ZAI_CN_BASE_URL
+	}];
+	for (const candidate of glm5) if ((await probeZaiChatCompletions({
+		baseUrl: candidate.baseUrl,
+		apiKey: params.apiKey,
+		modelId: "glm-5",
+		timeoutMs,
+		fetchFn: params.fetchFn
+	})).ok) return {
+		endpoint: candidate.endpoint,
+		baseUrl: candidate.baseUrl,
+		modelId: "glm-5",
+		note: `Verified GLM-5 on ${candidate.endpoint} endpoint.`
+	};
+	const coding = [{
+		endpoint: "coding-global",
+		baseUrl: ZAI_CODING_GLOBAL_BASE_URL
+	}, {
+		endpoint: "coding-cn",
+		baseUrl: ZAI_CODING_CN_BASE_URL
+	}];
+	for (const candidate of coding) if ((await probeZaiChatCompletions({
+		baseUrl: candidate.baseUrl,
+		apiKey: params.apiKey,
+		modelId: "glm-4.7",
+		timeoutMs,
+		fetchFn: params.fetchFn
+	})).ok) return {
+		endpoint: candidate.endpoint,
+		baseUrl: candidate.baseUrl,
+		modelId: "glm-4.7",
+		note: "Coding Plan endpoint detected; GLM-5 is not available there. Defaulting to GLM-4.7."
+	};
+	return null;
+}
+
 //#endregion
 //#region src/commands/auth-choice.apply.api-providers.ts
 async function applyAuthChoiceApiProviders(params) {
@@ -895,6 +1233,7 @@ async function applyAuthChoiceApiProviders(params) {
 	let authChoice = params.authChoice;
 	if (authChoice === "apiKey" && params.opts?.tokenProvider && params.opts.tokenProvider !== "anthropic" && params.opts.tokenProvider !== "openai") {
 		if (params.opts.tokenProvider === "openrouter") authChoice = "openrouter-api-key";
+		else if (params.opts.tokenProvider === "litellm") authChoice = "litellm-api-key";
 		else if (params.opts.tokenProvider === "vercel-ai-gateway") authChoice = "ai-gateway-api-key";
 		else if (params.opts.tokenProvider === "cloudflare-ai-gateway") authChoice = "cloudflare-ai-gateway-api-key";
 		else if (params.opts.tokenProvider === "moonshot") authChoice = "moonshot-api-key";
@@ -905,68 +1244,67 @@ async function applyAuthChoiceApiProviders(params) {
 		else if (params.opts.tokenProvider === "synthetic") authChoice = "synthetic-api-key";
 		else if (params.opts.tokenProvider === "venice") authChoice = "venice-api-key";
 		else if (params.opts.tokenProvider === "together") authChoice = "together-api-key";
+		else if (params.opts.tokenProvider === "huggingface") authChoice = "huggingface-api-key";
 		else if (params.opts.tokenProvider === "opencode") authChoice = "opencode-zen";
 		else if (params.opts.tokenProvider === "qianfan") authChoice = "qianfan-api-key";
 	}
-	if (authChoice === "openrouter-api-key") {
+	if (authChoice === "openrouter-api-key") return applyAuthChoiceOpenRouter(params);
+	if (authChoice === "litellm-api-key") {
 		const store = ensureAuthProfileStore(params.agentDir, { allowKeychainPrompt: false });
 		const existingProfileId = resolveAuthProfileOrder({
 			cfg: nextConfig,
 			store,
-			provider: "openrouter"
+			provider: "litellm"
 		}).find((profileId) => Boolean(store.profiles[profileId]));
 		const existingCred = existingProfileId ? store.profiles[existingProfileId] : void 0;
-		let profileId = "openrouter:default";
-		let mode = "api_key";
+		let profileId = "litellm:default";
 		let hasCredential = false;
-		if (existingProfileId && existingCred?.type) {
+		if (existingProfileId && existingCred?.type === "api_key") {
 			profileId = existingProfileId;
-			mode = existingCred.type === "oauth" ? "oauth" : existingCred.type === "token" ? "token" : "api_key";
 			hasCredential = true;
 		}
-		if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "openrouter") {
-			await setOpenrouterApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+		if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "litellm") {
+			await setLitellmApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
 			hasCredential = true;
 		}
 		if (!hasCredential) {
-			const envKey = resolveEnvApiKey("openrouter");
+			await params.prompter.note("LiteLLM provides a unified API to 100+ LLM providers.\nGet your API key from your LiteLLM proxy or https://litellm.ai\nDefault proxy runs on http://localhost:4000", "LiteLLM");
+			const envKey = resolveEnvApiKey("litellm");
 			if (envKey) {
 				if (await params.prompter.confirm({
-					message: `Use existing OPENROUTER_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+					message: `Use existing LITELLM_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
 					initialValue: true
 				})) {
-					await setOpenrouterApiKey(envKey.apiKey, params.agentDir);
+					await setLitellmApiKey(envKey.apiKey, params.agentDir);
 					hasCredential = true;
 				}
 			}
-		}
-		if (!hasCredential) {
-			const key = await params.prompter.text({
-				message: "Enter OpenRouter API key",
-				validate: validateApiKeyInput
-			});
-			await setOpenrouterApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
-			hasCredential = true;
+			if (!hasCredential) {
+				const key = await params.prompter.text({
+					message: "Enter LiteLLM API key",
+					validate: validateApiKeyInput
+				});
+				await setLitellmApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
+				hasCredential = true;
+			}
 		}
 		if (hasCredential) nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId,
-			provider: "openrouter",
-			mode
+			provider: "litellm",
+			mode: "api_key"
 		});
-		{
-			const applied = await applyDefaultModelChoice({
-				config: nextConfig,
-				setDefaultModel: params.setDefaultModel,
-				defaultModel: OPENROUTER_DEFAULT_MODEL_REF,
-				applyDefaultConfig: applyOpenrouterConfig,
-				applyProviderConfig: applyOpenrouterProviderConfig,
-				noteDefault: OPENROUTER_DEFAULT_MODEL_REF,
-				noteAgentModel,
-				prompter: params.prompter
-			});
-			nextConfig = applied.config;
-			agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
-		}
+		const applied = await applyDefaultModelChoice({
+			config: nextConfig,
+			setDefaultModel: params.setDefaultModel,
+			defaultModel: LITELLM_DEFAULT_MODEL_REF,
+			applyDefaultConfig: applyLitellmConfig,
+			applyProviderConfig: applyLitellmProviderConfig,
+			noteDefault: LITELLM_DEFAULT_MODEL_REF,
+			noteAgentModel,
+			prompter: params.prompter
+		});
+		nextConfig = applied.config;
+		agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
 		return {
 			config: nextConfig,
 			agentModelOverride
@@ -993,7 +1331,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Vercel AI Gateway API key",
 				validate: validateApiKeyInput
 			});
-			await setVercelAiGatewayApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setVercelAiGatewayApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "vercel-ai-gateway:default",
@@ -1027,16 +1365,16 @@ async function applyAuthChoiceApiProviders(params) {
 			if (!accountId) {
 				const value = await params.prompter.text({
 					message: "Enter Cloudflare Account ID",
-					validate: (val) => String(val).trim() ? void 0 : "Account ID is required"
+					validate: (val) => String(val ?? "").trim() ? void 0 : "Account ID is required"
 				});
-				accountId = String(value).trim();
+				accountId = String(value ?? "").trim();
 			}
 			if (!gatewayId) {
 				const value = await params.prompter.text({
 					message: "Enter Cloudflare AI Gateway ID",
-					validate: (val) => String(val).trim() ? void 0 : "Gateway ID is required"
+					validate: (val) => String(val ?? "").trim() ? void 0 : "Gateway ID is required"
 				});
-				gatewayId = String(value).trim();
+				gatewayId = String(value ?? "").trim();
 			}
 		};
 		const optsApiKey = normalizeApiKeyInput(params.opts?.cloudflareAiGatewayApiKey ?? "");
@@ -1066,7 +1404,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Cloudflare AI Gateway API key",
 				validate: validateApiKeyInput
 			});
-			await setCloudflareAiGatewayConfig(accountId, gatewayId, normalizeApiKeyInput(String(key)), params.agentDir);
+			await setCloudflareAiGatewayConfig(accountId, gatewayId, normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 			hasCredential = true;
 		}
 		if (hasCredential) nextConfig = applyAuthProfileConfig(nextConfig, {
@@ -1120,7 +1458,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Moonshot API key",
 				validate: validateApiKeyInput
 			});
-			await setMoonshotApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setMoonshotApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "moonshot:default",
@@ -1166,7 +1504,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Moonshot API key (.cn)",
 				validate: validateApiKeyInput
 			});
-			await setMoonshotApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setMoonshotApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "moonshot:default",
@@ -1214,7 +1552,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Kimi Coding API key",
 				validate: validateApiKeyInput
 			});
-			await setKimiCodingApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setKimiCodingApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "kimi-coding:default",
@@ -1261,7 +1599,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Gemini API key",
 				validate: validateApiKeyInput
 			});
-			await setGeminiApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setGeminiApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "google:default",
@@ -1281,10 +1619,17 @@ async function applyAuthChoiceApiProviders(params) {
 			agentModelOverride
 		};
 	}
-	if (authChoice === "zai-api-key") {
+	if (authChoice === "zai-api-key" || authChoice === "zai-coding-global" || authChoice === "zai-coding-cn" || authChoice === "zai-global" || authChoice === "zai-cn") {
+		let endpoint;
+		if (authChoice === "zai-coding-global") endpoint = "coding-global";
+		else if (authChoice === "zai-coding-cn") endpoint = "coding-cn";
+		else if (authChoice === "zai-global") endpoint = "global";
+		else if (authChoice === "zai-cn") endpoint = "cn";
 		let hasCredential = false;
+		let apiKey = "";
 		if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "zai") {
-			await setZaiApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+			apiKey = normalizeApiKeyInput(params.opts.token);
+			await setZaiApiKey(apiKey, params.agentDir);
 			hasCredential = true;
 		}
 		const envKey = resolveEnvApiKey("zai");
@@ -1293,7 +1638,8 @@ async function applyAuthChoiceApiProviders(params) {
 				message: `Use existing ZAI_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
 				initialValue: true
 			})) {
-				await setZaiApiKey(envKey.apiKey, params.agentDir);
+				apiKey = envKey.apiKey;
+				await setZaiApiKey(apiKey, params.agentDir);
 				hasCredential = true;
 			}
 		}
@@ -1302,42 +1648,67 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Z.AI API key",
 				validate: validateApiKeyInput
 			});
-			await setZaiApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			apiKey = normalizeApiKeyInput(String(key ?? ""));
+			await setZaiApiKey(apiKey, params.agentDir);
+		}
+		let modelIdOverride;
+		if (!endpoint) {
+			const detected = await detectZaiEndpoint({ apiKey });
+			if (detected) {
+				endpoint = detected.endpoint;
+				modelIdOverride = detected.modelId;
+				await params.prompter.note(detected.note, "Z.AI endpoint");
+			} else endpoint = await params.prompter.select({
+				message: "Select Z.AI endpoint",
+				options: [
+					{
+						value: "coding-global",
+						label: "Coding-Plan-Global",
+						hint: "GLM Coding Plan Global (api.z.ai)"
+					},
+					{
+						value: "coding-cn",
+						label: "Coding-Plan-CN",
+						hint: "GLM Coding Plan CN (open.bigmodel.cn)"
+					},
+					{
+						value: "global",
+						label: "Global",
+						hint: "Z.AI Global (api.z.ai)"
+					},
+					{
+						value: "cn",
+						label: "CN",
+						hint: "Z.AI CN (open.bigmodel.cn)"
+					}
+				],
+				initialValue: "global"
+			});
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "zai:default",
 			provider: "zai",
 			mode: "api_key"
 		});
-		{
-			const applied = await applyDefaultModelChoice({
-				config: nextConfig,
-				setDefaultModel: params.setDefaultModel,
-				defaultModel: ZAI_DEFAULT_MODEL_REF,
-				applyDefaultConfig: applyZaiConfig,
-				applyProviderConfig: (config) => ({
-					...config,
-					agents: {
-						...config.agents,
-						defaults: {
-							...config.agents?.defaults,
-							models: {
-								...config.agents?.defaults?.models,
-								[ZAI_DEFAULT_MODEL_REF]: {
-									...config.agents?.defaults?.models?.[ZAI_DEFAULT_MODEL_REF],
-									alias: config.agents?.defaults?.models?.[ZAI_DEFAULT_MODEL_REF]?.alias ?? "GLM"
-								}
-							}
-						}
-					}
-				}),
-				noteDefault: ZAI_DEFAULT_MODEL_REF,
-				noteAgentModel,
-				prompter: params.prompter
-			});
-			nextConfig = applied.config;
-			agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
-		}
+		const defaultModel = modelIdOverride ? `zai/${modelIdOverride}` : ZAI_DEFAULT_MODEL_REF;
+		const applied = await applyDefaultModelChoice({
+			config: nextConfig,
+			setDefaultModel: params.setDefaultModel,
+			defaultModel,
+			applyDefaultConfig: (config) => applyZaiConfig(config, {
+				endpoint,
+				...modelIdOverride ? { modelId: modelIdOverride } : {}
+			}),
+			applyProviderConfig: (config) => applyZaiProviderConfig(config, {
+				endpoint,
+				...modelIdOverride ? { modelId: modelIdOverride } : {}
+			}),
+			noteDefault: defaultModel,
+			noteAgentModel,
+			prompter: params.prompter
+		});
+		nextConfig = applied.config;
+		agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
 		return {
 			config: nextConfig,
 			agentModelOverride
@@ -1364,7 +1735,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Xiaomi API key",
 				validate: validateApiKeyInput
 			});
-			await setXiaomiApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setXiaomiApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "xiaomi:default",
@@ -1391,13 +1762,13 @@ async function applyAuthChoiceApiProviders(params) {
 		};
 	}
 	if (authChoice === "synthetic-api-key") {
-		if (params.opts?.token && params.opts?.tokenProvider === "synthetic") await setSyntheticApiKey(String(params.opts.token).trim(), params.agentDir);
+		if (params.opts?.token && params.opts?.tokenProvider === "synthetic") await setSyntheticApiKey(String(params.opts.token ?? "").trim(), params.agentDir);
 		else {
 			const key = await params.prompter.text({
 				message: "Enter Synthetic API key",
 				validate: (value) => value?.trim() ? void 0 : "Required"
 			});
-			await setSyntheticApiKey(String(key).trim(), params.agentDir);
+			await setSyntheticApiKey(String(key ?? "").trim(), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "synthetic:default",
@@ -1449,7 +1820,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Venice AI API key",
 				validate: validateApiKeyInput
 			});
-			await setVeniceApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setVeniceApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "venice:default",
@@ -1501,7 +1872,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter OpenCode Zen API key",
 				validate: validateApiKeyInput
 			});
-			await setOpencodeZenApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setOpencodeZenApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "opencode:default",
@@ -1549,7 +1920,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter Together AI API key",
 				validate: validateApiKeyInput
 			});
-			await setTogetherApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			await setTogetherApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "together:default",
@@ -1575,6 +1946,10 @@ async function applyAuthChoiceApiProviders(params) {
 			agentModelOverride
 		};
 	}
+	if (authChoice === "huggingface-api-key") return applyAuthChoiceHuggingface({
+		...params,
+		authChoice
+	});
 	if (authChoice === "qianfan-api-key") {
 		let hasCredential = false;
 		if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "qianfan") {
@@ -1597,7 +1972,7 @@ async function applyAuthChoiceApiProviders(params) {
 				message: "Enter QIANFAN API key",
 				validate: validateApiKeyInput
 			});
-			setQianfanApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+			setQianfanApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
 		}
 		nextConfig = applyAuthProfileConfig(nextConfig, {
 			profileId: "qianfan:default",
@@ -1844,7 +2219,7 @@ async function applyAuthChoiceMiniMax(params) {
 		label: "MiniMax"
 	});
 	if (params.authChoice === "minimax-cloud" || params.authChoice === "minimax-api" || params.authChoice === "minimax-api-lightning") {
-		const modelId = params.authChoice === "minimax-api-lightning" ? "MiniMax-M2.1-lightning" : "MiniMax-M2.1";
+		const modelId = params.authChoice === "minimax-api-lightning" ? "MiniMax-M2.5-Lightning" : "MiniMax-M2.5";
 		let hasCredential = false;
 		const envKey = resolveEnvApiKey("minimax");
 		if (envKey) {
@@ -2376,6 +2751,97 @@ async function applyAuthChoiceQwenPortal(params) {
 	});
 }
 
+//#endregion
+//#region src/commands/auth-choice.apply.vllm.ts
+const VLLM_DEFAULT_BASE_URL$1 = "http://127.0.0.1:8000/v1";
+const VLLM_DEFAULT_CONTEXT_WINDOW$1 = 128e3;
+const VLLM_DEFAULT_MAX_TOKENS$1 = 8192;
+const VLLM_DEFAULT_COST$1 = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+};
+function applyVllmDefaultModel(cfg, modelRef) {
+	const existingModel = cfg.agents?.defaults?.model;
+	const fallbacks = existingModel && typeof existingModel === "object" && "fallbacks" in existingModel ? existingModel.fallbacks : void 0;
+	return {
+		...cfg,
+		agents: {
+			...cfg.agents,
+			defaults: {
+				...cfg.agents?.defaults,
+				model: {
+					...fallbacks ? { fallbacks } : void 0,
+					primary: modelRef
+				}
+			}
+		}
+	};
+}
+async function applyAuthChoiceVllm(params) {
+	if (params.authChoice !== "vllm") return null;
+	const baseUrlRaw = await params.prompter.text({
+		message: "vLLM base URL",
+		initialValue: VLLM_DEFAULT_BASE_URL$1,
+		placeholder: VLLM_DEFAULT_BASE_URL$1,
+		validate: (value) => value?.trim() ? void 0 : "Required"
+	});
+	const apiKeyRaw = await params.prompter.text({
+		message: "vLLM API key",
+		placeholder: "sk-... (or any non-empty string)",
+		validate: (value) => value?.trim() ? void 0 : "Required"
+	});
+	const modelIdRaw = await params.prompter.text({
+		message: "vLLM model",
+		placeholder: "meta-llama/Meta-Llama-3-8B-Instruct",
+		validate: (value) => value?.trim() ? void 0 : "Required"
+	});
+	const baseUrl = String(baseUrlRaw ?? "").trim().replace(/\/+$/, "");
+	const apiKey = String(apiKeyRaw ?? "").trim();
+	const modelId = String(modelIdRaw ?? "").trim();
+	const modelRef = `vllm/${modelId}`;
+	await upsertAuthProfileWithLock({
+		profileId: "vllm:default",
+		credential: {
+			type: "api_key",
+			provider: "vllm",
+			key: apiKey
+		},
+		agentDir: params.agentDir
+	});
+	const nextConfig = {
+		...params.config,
+		models: {
+			...params.config.models,
+			mode: params.config.models?.mode ?? "merge",
+			providers: {
+				...params.config.models?.providers,
+				vllm: {
+					baseUrl,
+					api: "openai-completions",
+					apiKey: "VLLM_API_KEY",
+					models: [{
+						id: modelId,
+						name: modelId,
+						reasoning: false,
+						input: ["text"],
+						cost: VLLM_DEFAULT_COST$1,
+						contextWindow: VLLM_DEFAULT_CONTEXT_WINDOW$1,
+						maxTokens: VLLM_DEFAULT_MAX_TOKENS$1
+					}]
+				}
+			}
+		}
+	};
+	if (!params.setDefaultModel) return {
+		config: nextConfig,
+		agentModelOverride: modelRef
+	};
+	await params.prompter.note(`Default model set to ${modelRef}`, "Model configured");
+	return { config: applyVllmDefaultModel(nextConfig, modelRef) };
+}
+
 //#endregion
 //#region src/commands/auth-choice.apply.xai.ts
 async function applyAuthChoiceXAI(params) {
@@ -2441,6 +2907,7 @@ async function applyAuthChoiceXAI(params) {
 async function applyAuthChoice(params) {
 	const handlers = [
 		applyAuthChoiceAnthropic,
+		applyAuthChoiceVllm,
 		applyAuthChoiceOpenAI,
 		applyAuthChoiceOAuth,
 		applyAuthChoiceApiProviders,
@@ -2508,6 +2975,7 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
 	"claude-cli": "anthropic",
 	token: "anthropic",
 	apiKey: "anthropic",
+	vllm: "vllm",
 	"openai-codex": "openai-codex",
 	"codex-cli": "openai-codex",
 	chutes: "chutes",
@@ -2522,10 +2990,15 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
 	"google-antigravity": "google-antigravity",
 	"google-gemini-cli": "google-gemini-cli",
 	"zai-api-key": "zai",
+	"zai-coding-global": "zai",
+	"zai-coding-cn": "zai",
+	"zai-global": "zai",
+	"zai-cn": "zai",
 	"xiaomi-api-key": "xiaomi",
 	"synthetic-api-key": "synthetic",
 	"venice-api-key": "venice",
 	"together-api-key": "together",
+	"huggingface-api-key": "huggingface",
 	"github-copilot": "github-copilot",
 	"copilot-proxy": "copilot-proxy",
 	"minimax-cloud": "minimax",
@@ -2534,9 +3007,11 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
 	minimax: "lmstudio",
 	"opencode-zen": "opencode",
 	"xai-api-key": "xai",
+	"litellm-api-key": "litellm",
 	"qwen-portal": "qwen-portal",
 	"minimax-portal": "minimax-portal",
-	"qianfan-api-key": "qianfan"
+	"qianfan-api-key": "qianfan",
+	"custom-api-key": "custom"
 };
 function resolvePreferredProviderForAuthChoice(choice) {
 	return PREFERRED_PROVIDER_BY_AUTH_CHOICE[choice];
@@ -2546,7 +3021,17 @@ function resolvePreferredProviderForAuthChoice(choice) {
 //#region src/commands/model-picker.ts
 const KEEP_VALUE = "__keep__";
 const MANUAL_VALUE = "__manual__";
+const VLLM_VALUE = "__vllm__";
 const PROVIDER_FILTER_THRESHOLD = 30;
+const VLLM_DEFAULT_BASE_URL = "http://127.0.0.1:8000/v1";
+const VLLM_DEFAULT_CONTEXT_WINDOW = 128e3;
+const VLLM_DEFAULT_MAX_TOKENS = 8192;
+const VLLM_DEFAULT_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+};
 const HIDDEN_ROUTER_MODELS = new Set(["openrouter/auto"]);
 function hasAuthForProvider(provider, cfg, store) {
 	if (listProfilesForProvider(store, provider).length > 0) return true;
@@ -2589,6 +3074,7 @@ async function promptDefaultModel(params) {
 	const cfg = params.config;
 	const allowKeep = params.allowKeep ?? true;
 	const includeManual = params.includeManual ?? true;
+	const includeVllm = params.includeVllm ?? false;
 	const ignoreAllowlist = params.ignoreAllowlist ?? false;
 	const preferredProviderRaw = params.preferredProvider?.trim();
 	const preferredProvider = preferredProviderRaw ? normalizeProviderId(preferredProviderRaw) : void 0;
@@ -2647,7 +3133,8 @@ async function promptDefaultModel(params) {
 		if (selection !== "*") models = models.filter((entry) => entry.provider === selection);
 	}
 	if (hasPreferredProvider && preferredProvider) models = models.filter((entry) => entry.provider === preferredProvider);
-	const authStore = ensureAuthProfileStore(params.agentDir, { allowKeychainPrompt: false });
+	const agentDir = params.agentDir;
+	const authStore = ensureAuthProfileStore(agentDir, { allowKeychainPrompt: false });
 	const authCache = /* @__PURE__ */ new Map();
 	const hasAuth = (provider) => {
 		const cached = authCache.get(provider);
@@ -2666,6 +3153,11 @@ async function promptDefaultModel(params) {
 		value: MANUAL_VALUE,
 		label: "Enter model manually"
 	});
+	if (includeVllm && agentDir) options.push({
+		value: VLLM_VALUE,
+		label: "vLLM (custom)",
+		hint: "Enter vLLM URL + API key + model"
+	});
 	const seen = /* @__PURE__ */ new Set();
 	const addModelOption = (entry) => {
 		const key = modelKey(entry.provider, entry.id);
@@ -2707,6 +3199,68 @@ async function promptDefaultModel(params) {
 		allowBlank: false,
 		initialValue: configuredRaw || resolvedKey || void 0
 	});
+	if (selection === VLLM_VALUE) {
+		if (!agentDir) {
+			await params.prompter.note("vLLM setup requires an agent directory context.", "vLLM not available");
+			return {};
+		}
+		const baseUrlRaw = await params.prompter.text({
+			message: "vLLM base URL",
+			initialValue: VLLM_DEFAULT_BASE_URL,
+			placeholder: VLLM_DEFAULT_BASE_URL,
+			validate: (value) => value?.trim() ? void 0 : "Required"
+		});
+		const apiKeyRaw = await params.prompter.text({
+			message: "vLLM API key",
+			placeholder: "sk-... (or any non-empty string)",
+			validate: (value) => value?.trim() ? void 0 : "Required"
+		});
+		const modelIdRaw = await params.prompter.text({
+			message: "vLLM model",
+			placeholder: "meta-llama/Meta-Llama-3-8B-Instruct",
+			validate: (value) => value?.trim() ? void 0 : "Required"
+		});
+		const baseUrl = String(baseUrlRaw ?? "").trim().replace(/\/+$/, "");
+		const apiKey = String(apiKeyRaw ?? "").trim();
+		const modelId = String(modelIdRaw ?? "").trim();
+		await upsertAuthProfileWithLock({
+			profileId: "vllm:default",
+			credential: {
+				type: "api_key",
+				provider: "vllm",
+				key: apiKey
+			},
+			agentDir
+		});
+		const nextConfig = {
+			...cfg,
+			models: {
+				...cfg.models,
+				mode: cfg.models?.mode ?? "merge",
+				providers: {
+					...cfg.models?.providers,
+					vllm: {
+						baseUrl,
+						api: "openai-completions",
+						apiKey: "VLLM_API_KEY",
+						models: [{
+							id: modelId,
+							name: modelId,
+							reasoning: false,
+							input: ["text"],
+							cost: VLLM_DEFAULT_COST,
+							contextWindow: VLLM_DEFAULT_CONTEXT_WINDOW,
+							maxTokens: VLLM_DEFAULT_MAX_TOKENS
+						}]
+					}
+				}
+			}
+		};
+		return {
+			model: `vllm/${modelId}`,
+			config: nextConfig
+		};
+	}
 	return { model: String(selection) };
 }
 async function promptModelAllowlist(params) {
@@ -2880,6 +3434,479 @@ function applyModelFallbacksFromSelection(cfg, selection) {
 	};
 }
 
+//#endregion
+//#region src/commands/onboard-custom.ts
+const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434/v1";
+const DEFAULT_CONTEXT_WINDOW = 4096;
+const DEFAULT_MAX_TOKENS = 4096;
+const VERIFY_TIMEOUT_MS = 1e4;
+var CustomApiError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.name = "CustomApiError";
+		this.code = code;
+	}
+};
+const COMPATIBILITY_OPTIONS = [
+	{
+		value: "openai",
+		label: "OpenAI-compatible",
+		hint: "Uses /chat/completions"
+	},
+	{
+		value: "anthropic",
+		label: "Anthropic-compatible",
+		hint: "Uses /messages"
+	},
+	{
+		value: "unknown",
+		label: "Unknown (detect automatically)",
+		hint: "Probes OpenAI then Anthropic endpoints"
+	}
+];
+function normalizeEndpointId(raw) {
+	const trimmed = raw.trim().toLowerCase();
+	if (!trimmed) return "";
+	return trimmed.replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildEndpointIdFromUrl(baseUrl) {
+	try {
+		const url = new URL(baseUrl);
+		return normalizeEndpointId(`custom-${url.hostname.replace(/[^a-z0-9]+/gi, "-").toLowerCase()}${url.port ? `-${url.port}` : ""}`) || "custom";
+	} catch {
+		return "custom";
+	}
+}
+function resolveUniqueEndpointId(params) {
+	const normalized = normalizeEndpointId(params.requestedId) || "custom";
+	const existing = params.providers[normalized];
+	if (!existing?.baseUrl || existing.baseUrl === params.baseUrl) return {
+		providerId: normalized,
+		renamed: false
+	};
+	let suffix = 2;
+	let candidate = `${normalized}-${suffix}`;
+	while (params.providers[candidate]) {
+		suffix += 1;
+		candidate = `${normalized}-${suffix}`;
+	}
+	return {
+		providerId: candidate,
+		renamed: true
+	};
+}
+function resolveAliasError(params) {
+	const trimmed = params.raw.trim();
+	if (!trimmed) return;
+	let normalized;
+	try {
+		normalized = normalizeAlias(trimmed);
+	} catch (err) {
+		return err instanceof Error ? err.message : "Alias is invalid.";
+	}
+	const aliasIndex = buildModelAliasIndex({
+		cfg: params.cfg,
+		defaultProvider: DEFAULT_PROVIDER
+	});
+	const aliasKey = normalized.toLowerCase();
+	const existing = aliasIndex.byAlias.get(aliasKey);
+	if (!existing) return;
+	const existingKey = modelKey(existing.ref.provider, existing.ref.model);
+	if (existingKey === params.modelRef) return;
+	return `Alias ${normalized} already points to ${existingKey}.`;
+}
+function buildOpenAiHeaders(apiKey) {
+	const headers = {};
+	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+	return headers;
+}
+function buildAnthropicHeaders(apiKey) {
+	const headers = { "anthropic-version": "2023-06-01" };
+	if (apiKey) headers["x-api-key"] = apiKey;
+	return headers;
+}
+function formatVerificationError(error) {
+	if (!error) return "unknown error";
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return "unknown error";
+	}
+}
+async function requestOpenAiVerification(params) {
+	const endpoint = new URL("chat/completions", params.baseUrl.endsWith("/") ? params.baseUrl : `${params.baseUrl}/`).href;
+	try {
+		const res = await fetchWithTimeout(endpoint, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...buildOpenAiHeaders(params.apiKey)
+			},
+			body: JSON.stringify({
+				model: params.modelId,
+				messages: [{
+					role: "user",
+					content: "Hi"
+				}],
+				max_tokens: 5
+			})
+		}, VERIFY_TIMEOUT_MS);
+		return {
+			ok: res.ok,
+			status: res.status
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
+}
+async function requestAnthropicVerification(params) {
+	const endpoint = new URL("messages", params.baseUrl.endsWith("/") ? params.baseUrl : `${params.baseUrl}/`).href;
+	try {
+		const res = await fetchWithTimeout(endpoint, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...buildAnthropicHeaders(params.apiKey)
+			},
+			body: JSON.stringify({
+				model: params.modelId,
+				max_tokens: 16,
+				messages: [{
+					role: "user",
+					content: "Hi"
+				}]
+			})
+		}, VERIFY_TIMEOUT_MS);
+		return {
+			ok: res.ok,
+			status: res.status
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
+}
+async function promptBaseUrlAndKey(params) {
+	const baseUrlInput = await params.prompter.text({
+		message: "API Base URL",
+		initialValue: params.initialBaseUrl ?? DEFAULT_OLLAMA_BASE_URL,
+		placeholder: "https://api.example.com/v1",
+		validate: (val) => {
+			try {
+				new URL(val);
+				return;
+			} catch {
+				return "Please enter a valid URL (e.g. http://...)";
+			}
+		}
+	});
+	const apiKeyInput = await params.prompter.text({
+		message: "API Key (leave blank if not required)",
+		placeholder: "sk-...",
+		initialValue: ""
+	});
+	return {
+		baseUrl: baseUrlInput.trim(),
+		apiKey: apiKeyInput.trim()
+	};
+}
+function resolveProviderApi(compatibility) {
+	return compatibility === "anthropic" ? "anthropic-messages" : "openai-completions";
+}
+function parseCustomApiCompatibility(raw) {
+	const compatibilityRaw = raw?.trim().toLowerCase();
+	if (!compatibilityRaw) return "openai";
+	if (compatibilityRaw !== "openai" && compatibilityRaw !== "anthropic") throw new CustomApiError("invalid_compatibility", "Invalid --custom-compatibility (use \"openai\" or \"anthropic\").");
+	return compatibilityRaw;
+}
+function resolveCustomProviderId(params) {
+	const providers = params.config.models?.providers ?? {};
+	const baseUrl = params.baseUrl.trim();
+	const explicitProviderId = params.providerId?.trim();
+	if (explicitProviderId && !normalizeEndpointId(explicitProviderId)) throw new CustomApiError("invalid_provider_id", "Custom provider ID must include letters, numbers, or hyphens.");
+	const requestedProviderId = explicitProviderId || buildEndpointIdFromUrl(baseUrl);
+	const providerIdResult = resolveUniqueEndpointId({
+		requestedId: requestedProviderId,
+		baseUrl,
+		providers
+	});
+	return {
+		providerId: providerIdResult.providerId,
+		...providerIdResult.renamed ? { providerIdRenamedFrom: normalizeEndpointId(requestedProviderId) || "custom" } : {}
+	};
+}
+function parseNonInteractiveCustomApiFlags(params) {
+	const baseUrl = params.baseUrl?.trim() ?? "";
+	const modelId = params.modelId?.trim() ?? "";
+	if (!baseUrl || !modelId) throw new CustomApiError("missing_required", ["Auth choice \"custom-api-key\" requires a base URL and model ID.", "Use --custom-base-url and --custom-model-id."].join("\n"));
+	const apiKey = params.apiKey?.trim();
+	const providerId = params.providerId?.trim();
+	if (providerId && !normalizeEndpointId(providerId)) throw new CustomApiError("invalid_provider_id", "Custom provider ID must include letters, numbers, or hyphens.");
+	return {
+		baseUrl,
+		modelId,
+		compatibility: parseCustomApiCompatibility(params.compatibility),
+		...apiKey ? { apiKey } : {},
+		...providerId ? { providerId } : {}
+	};
+}
+function applyCustomApiConfig(params) {
+	const baseUrl = params.baseUrl.trim();
+	try {
+		new URL(baseUrl);
+	} catch {
+		throw new CustomApiError("invalid_base_url", "Custom provider base URL must be a valid URL.");
+	}
+	if (params.compatibility !== "openai" && params.compatibility !== "anthropic") throw new CustomApiError("invalid_compatibility", "Custom provider compatibility must be \"openai\" or \"anthropic\".");
+	const modelId = params.modelId.trim();
+	if (!modelId) throw new CustomApiError("invalid_model_id", "Custom provider model ID is required.");
+	const providerIdResult = resolveCustomProviderId({
+		config: params.config,
+		baseUrl,
+		providerId: params.providerId
+	});
+	const providerId = providerIdResult.providerId;
+	const providers = params.config.models?.providers ?? {};
+	const modelRef = modelKey(providerId, modelId);
+	const alias = params.alias?.trim() ?? "";
+	const aliasError = resolveAliasError({
+		raw: alias,
+		cfg: params.config,
+		modelRef
+	});
+	if (aliasError) throw new CustomApiError("invalid_alias", aliasError);
+	const existingProvider = providers[providerId];
+	const existingModels = Array.isArray(existingProvider?.models) ? existingProvider.models : [];
+	const hasModel = existingModels.some((model) => model.id === modelId);
+	const nextModel = {
+		id: modelId,
+		name: `${modelId} (Custom Provider)`,
+		contextWindow: DEFAULT_CONTEXT_WINDOW,
+		maxTokens: DEFAULT_MAX_TOKENS,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		reasoning: false
+	};
+	const mergedModels = hasModel ? existingModels : [...existingModels, nextModel];
+	const { apiKey: existingApiKey, ...existingProviderRest } = existingProvider ?? {};
+	const normalizedApiKey = params.apiKey?.trim() || (existingApiKey ? existingApiKey.trim() : void 0);
+	let config = {
+		...params.config,
+		models: {
+			...params.config.models,
+			mode: params.config.models?.mode ?? "merge",
+			providers: {
+				...providers,
+				[providerId]: {
+					...existingProviderRest,
+					baseUrl,
+					api: resolveProviderApi(params.compatibility),
+					...normalizedApiKey ? { apiKey: normalizedApiKey } : {},
+					models: mergedModels.length > 0 ? mergedModels : [nextModel]
+				}
+			}
+		}
+	};
+	config = applyPrimaryModel(config, modelRef);
+	if (alias) config = {
+		...config,
+		agents: {
+			...config.agents,
+			defaults: {
+				...config.agents?.defaults,
+				models: {
+					...config.agents?.defaults?.models,
+					[modelRef]: {
+						...config.agents?.defaults?.models?.[modelRef],
+						alias
+					}
+				}
+			}
+		}
+	};
+	return {
+		config,
+		providerId,
+		modelId,
+		...providerIdResult.providerIdRenamedFrom ? { providerIdRenamedFrom: providerIdResult.providerIdRenamedFrom } : {}
+	};
+}
+async function promptCustomApiConfig(params) {
+	const { prompter, runtime, config } = params;
+	const baseInput = await promptBaseUrlAndKey({ prompter });
+	let baseUrl = baseInput.baseUrl;
+	let apiKey = baseInput.apiKey;
+	const compatibilityChoice = await prompter.select({
+		message: "Endpoint compatibility",
+		options: COMPATIBILITY_OPTIONS.map((option) => ({
+			value: option.value,
+			label: option.label,
+			hint: option.hint
+		}))
+	});
+	let modelId = (await prompter.text({
+		message: "Model ID",
+		placeholder: "e.g. llama3, claude-3-7-sonnet",
+		validate: (val) => val.trim() ? void 0 : "Model ID is required"
+	})).trim();
+	let compatibility = compatibilityChoice === "unknown" ? null : compatibilityChoice;
+	while (true) {
+		let verifiedFromProbe = false;
+		if (!compatibility) {
+			const probeSpinner = prompter.progress("Detecting endpoint type...");
+			if ((await requestOpenAiVerification({
+				baseUrl,
+				apiKey,
+				modelId
+			})).ok) {
+				probeSpinner.stop("Detected OpenAI-compatible endpoint.");
+				compatibility = "openai";
+				verifiedFromProbe = true;
+			} else if ((await requestAnthropicVerification({
+				baseUrl,
+				apiKey,
+				modelId
+			})).ok) {
+				probeSpinner.stop("Detected Anthropic-compatible endpoint.");
+				compatibility = "anthropic";
+				verifiedFromProbe = true;
+			} else {
+				probeSpinner.stop("Could not detect endpoint type.");
+				await prompter.note("This endpoint did not respond to OpenAI or Anthropic style requests.", "Endpoint detection");
+				const retryChoice = await prompter.select({
+					message: "What would you like to change?",
+					options: [
+						{
+							value: "baseUrl",
+							label: "Change base URL"
+						},
+						{
+							value: "model",
+							label: "Change model"
+						},
+						{
+							value: "both",
+							label: "Change base URL and model"
+						}
+					]
+				});
+				if (retryChoice === "baseUrl" || retryChoice === "both") {
+					const retryInput = await promptBaseUrlAndKey({
+						prompter,
+						initialBaseUrl: baseUrl
+					});
+					baseUrl = retryInput.baseUrl;
+					apiKey = retryInput.apiKey;
+				}
+				if (retryChoice === "model" || retryChoice === "both") modelId = (await prompter.text({
+					message: "Model ID",
+					placeholder: "e.g. llama3, claude-3-7-sonnet",
+					validate: (val) => val.trim() ? void 0 : "Model ID is required"
+				})).trim();
+				continue;
+			}
+		}
+		if (verifiedFromProbe) break;
+		const verifySpinner = prompter.progress("Verifying...");
+		const result = compatibility === "anthropic" ? await requestAnthropicVerification({
+			baseUrl,
+			apiKey,
+			modelId
+		}) : await requestOpenAiVerification({
+			baseUrl,
+			apiKey,
+			modelId
+		});
+		if (result.ok) {
+			verifySpinner.stop("Verification successful.");
+			break;
+		}
+		if (result.status !== void 0) verifySpinner.stop(`Verification failed: status ${result.status}`);
+		else verifySpinner.stop(`Verification failed: ${formatVerificationError(result.error)}`);
+		const retryChoice = await prompter.select({
+			message: "What would you like to change?",
+			options: [
+				{
+					value: "baseUrl",
+					label: "Change base URL"
+				},
+				{
+					value: "model",
+					label: "Change model"
+				},
+				{
+					value: "both",
+					label: "Change base URL and model"
+				}
+			]
+		});
+		if (retryChoice === "baseUrl" || retryChoice === "both") {
+			const retryInput = await promptBaseUrlAndKey({
+				prompter,
+				initialBaseUrl: baseUrl
+			});
+			baseUrl = retryInput.baseUrl;
+			apiKey = retryInput.apiKey;
+		}
+		if (retryChoice === "model" || retryChoice === "both") modelId = (await prompter.text({
+			message: "Model ID",
+			placeholder: "e.g. llama3, claude-3-7-sonnet",
+			validate: (val) => val.trim() ? void 0 : "Model ID is required"
+		})).trim();
+		if (compatibilityChoice === "unknown") compatibility = null;
+	}
+	const providers = config.models?.providers ?? {};
+	const suggestedId = buildEndpointIdFromUrl(baseUrl);
+	const providerIdInput = await prompter.text({
+		message: "Endpoint ID",
+		initialValue: suggestedId,
+		placeholder: "custom",
+		validate: (value) => {
+			if (!normalizeEndpointId(value)) return "Endpoint ID is required.";
+		}
+	});
+	const aliasInput = await prompter.text({
+		message: "Model alias (optional)",
+		placeholder: "e.g. local, ollama",
+		initialValue: "",
+		validate: (value) => {
+			return resolveAliasError({
+				raw: value,
+				cfg: config,
+				modelRef: modelKey(resolveUniqueEndpointId({
+					requestedId: normalizeEndpointId(providerIdInput) || "custom",
+					baseUrl,
+					providers
+				}).providerId, modelId)
+			});
+		}
+	});
+	const result = applyCustomApiConfig({
+		config,
+		baseUrl,
+		modelId,
+		compatibility: compatibility ?? "openai",
+		apiKey,
+		providerId: providerIdInput,
+		alias: aliasInput
+	});
+	if (result.providerIdRenamedFrom && result.providerId) await prompter.note(`Endpoint ID "${result.providerIdRenamedFrom}" already exists for a different base URL. Using "${result.providerId}".`, "Endpoint ID");
+	runtime.log(`Configured custom provider: ${result.providerId}/${result.modelId}`);
+	return result;
+}
+
 //#endregion
 //#region src/commands/onboard-remote.ts
 const DEFAULT_GATEWAY_URL = "ws://127.0.0.1:18789";
@@ -3050,24 +4077,28 @@ function buildNodeInstallCommand(packageName, prefs) {
 			"pnpm",
 			"add",
 			"-g",
+			"--ignore-scripts",
 			packageName
 		];
 		case "yarn": return [
 			"yarn",
 			"global",
 			"add",
+			"--ignore-scripts",
 			packageName
 		];
 		case "bun": return [
 			"bun",
 			"add",
 			"-g",
+			"--ignore-scripts",
 			packageName
 		];
 		default: return [
 			"npm",
 			"install",
 			"-g",
+			"--ignore-scripts",
 			packageName
 		];
 	}
@@ -3512,4 +4543,4 @@ async function setupSkills(cfg, workspaceDir, runtime, prompter) {
 }
 
 //#endregion
-export { applyModelFallbacksFromSelection as a, promptModelAllowlist as c, applyAuthChoice as d, applyOpenAIConfig as f, discoverGatewayBeacons as g, promptAuthChoiceGrouped as h, applyModelAllowlist as i, resolvePreferredProviderForAuthChoice as l, applyGoogleGeminiModelDefault as m, installSkill as n, applyPrimaryModel as o, upsertSharedEnvVar as p, promptRemoteGatewayConfig as r, promptDefaultModel as s, setupSkills as t, warnIfModelConfigLooksOff as u };
+export { discoverGatewayBeacons as S, applyOpenAIConfig as _, applyCustomApiConfig as a, applyGoogleGeminiModelDefault as b, resolveCustomProviderId as c, applyPrimaryModel as d, promptDefaultModel as f, applyAuthChoice as g, warnIfModelConfigLooksOff as h, CustomApiError as i, applyModelAllowlist as l, resolvePreferredProviderForAuthChoice as m, installSkill as n, parseNonInteractiveCustomApiFlags as o, promptModelAllowlist as p, promptRemoteGatewayConfig as r, promptCustomApiConfig as s, setupSkills as t, applyModelFallbacksFromSelection as u, upsertSharedEnvVar as v, promptAuthChoiceGrouped as x, detectZaiEndpoint as y };