@poolzin/pool-bot 2026.2.0 → 2026.2.1

package/dist/commands/models/list.status-command.js

@@ -1,38 +1,49 @@
 import path from "node:path";
 import { resolvePoolbotAgentDir } from "../../agents/agent-paths.js";
+import { resolveAgentDir, resolveAgentModelFallbacksOverride, resolveAgentModelPrimary, } from "../../agents/agent-scope.js";
 import { buildAuthHealthSummary, DEFAULT_OAUTH_WARN_MS, formatRemainingShort, } from "../../agents/auth-health.js";
 import { ensureAuthProfileStore, resolveAuthStorePathForDisplay, resolveProfileUnusableUntilForDisplay, } from "../../agents/auth-profiles.js";
 import { resolveEnvApiKey } from "../../agents/model-auth.js";
-import { buildModelAliasIndex, parseModelRef, resolveConfiguredModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
-import { CONFIG_PATH, loadConfig } from "../../config/config.js";
-import { getShellEnvAppliedKeys, shouldEnableShellEnvFallback } from "../../infra/shell-env.js";
+import { buildModelAliasIndex, parseModelRef, resolveConfiguredModelRef, resolveDefaultModelForAgent, resolveModelRefFromString, } from "../../agents/model-selection.js";
+import { formatCliCommand } from "../../cli/command-format.js";
 import { withProgressTotals } from "../../cli/progress.js";
+import { CONFIG_PATH, loadConfig } from "../../config/config.js";
 import { formatUsageWindowSummary, loadProviderUsageSummary, resolveUsageProviderId, } from "../../infra/provider-usage.js";
-import { colorize, theme } from "../../terminal/theme.js";
+import { getShellEnvAppliedKeys, shouldEnableShellEnvFallback } from "../../infra/shell-env.js";
 import { renderTable } from "../../terminal/table.js";
-import { formatCliCommand } from "../../cli/command-format.js";
+import { colorize, theme } from "../../terminal/theme.js";
 import { shortenHomePath } from "../../utils.js";
 import { resolveProviderAuthOverview } from "./list.auth-overview.js";
 import { isRich } from "./list.format.js";
 import { describeProbeSummary, formatProbeLatency, runAuthProbes, sortProbeResults, } from "./list.probe.js";
-import { DEFAULT_MODEL, DEFAULT_PROVIDER, ensureFlagCompatibility } from "./shared.js";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER, ensureFlagCompatibility, resolveKnownAgentId, } from "./shared.js";
 export async function modelsStatusCommand(opts, runtime) {
     ensureFlagCompatibility(opts);
     if (opts.plain && opts.probe) {
         throw new Error("--probe cannot be used with --plain output.");
     }
     const cfg = loadConfig();
-    const resolved = resolveConfiguredModelRef({
-        cfg,
-        defaultProvider: DEFAULT_PROVIDER,
-        defaultModel: DEFAULT_MODEL,
-    });
+    const agentId = resolveKnownAgentId({ cfg, rawAgentId: opts.agent });
+    const agentDir = agentId ? resolveAgentDir(cfg, agentId) : resolvePoolbotAgentDir();
+    const agentModelPrimary = agentId ? resolveAgentModelPrimary(cfg, agentId) : undefined;
+    const agentFallbacksOverride = agentId
+        ? resolveAgentModelFallbacksOverride(cfg, agentId)
+        : undefined;
+    const resolved = agentId
+        ? resolveDefaultModelForAgent({ cfg, agentId })
+        : resolveConfiguredModelRef({
+            cfg,
+            defaultProvider: DEFAULT_PROVIDER,
+            defaultModel: DEFAULT_MODEL,
+        });
     const modelConfig = cfg.agents?.defaults?.model;
     const imageConfig = cfg.agents?.defaults?.imageModel;
-    const rawModel = typeof modelConfig === "string" ? modelConfig.trim() : (modelConfig?.primary?.trim() ?? "");
+    const rawDefaultsModel = typeof modelConfig === "string" ? modelConfig.trim() : (modelConfig?.primary?.trim() ?? "");
+    const rawModel = agentModelPrimary ?? rawDefaultsModel;
     const resolvedLabel = `${resolved.provider}/${resolved.model}`;
     const defaultLabel = rawModel || resolvedLabel;
-    const fallbacks = typeof modelConfig === "object" ? (modelConfig?.fallbacks ?? []) : [];
+    const defaultsFallbacks = typeof modelConfig === "object" ? (modelConfig?.fallbacks ?? []) : [];
+    const fallbacks = agentFallbacksOverride ?? defaultsFallbacks;
     const imageModel = typeof imageConfig === "string" ? imageConfig.trim() : (imageConfig?.primary?.trim() ?? "");
     const imageFallbacks = typeof imageConfig === "object" ? (imageConfig?.fallbacks ?? []) : [];
     const aliases = Object.entries(cfg.agents?.defaults?.models ?? {}).reduce((acc, [key, entry]) => {
@@ -42,8 +53,7 @@ export async function modelsStatusCommand(opts, runtime) {
         return acc;
     }, {});
     const allowed = Object.keys(cfg.agents?.defaults?.models ?? {});
-    const agentDir = resolvePoolbotAgentDir();
-    const store = ensureAuthProfileStore();
+    const store = ensureAuthProfileStore(agentDir);
     const modelsPath = path.join(agentDir, "models.json");
     const providersFromStore = new Set(Object.values(store.profiles)
         .map((profile) => profile.provider)
@@ -92,7 +102,7 @@ export async function modelsStatusCommand(opts, runtime) {
     ]))
         .map((p) => p.trim())
         .filter(Boolean)
-        .sort((a, b) => a.localeCompare(b));
+        .toSorted((a, b) => a.localeCompare(b));
     const applied = getShellEnvAppliedKeys();
     const shellFallbackEnabled = shouldEnableShellEnvFallback(process.env) || cfg.env?.shellEnv?.enabled === true;
     const providerAuth = providers
@@ -104,7 +114,7 @@ export async function modelsStatusCommand(opts, runtime) {
     const providerAuthMap = new Map(providerAuth.map((entry) => [entry.provider, entry]));
     const missingProvidersInUse = Array.from(providersInUse)
         .filter((provider) => !providerAuthMap.has(provider))
-        .sort((a, b) => a.localeCompare(b));
+        .toSorted((a, b) => a.localeCompare(b));
     const probeProfileIds = (() => {
         if (!opts.probeProfile)
             return [];
@@ -193,7 +203,7 @@ export async function modelsStatusCommand(opts, runtime) {
                 remainingMs: unusableUntil - now,
             });
         }
-        return out.sort((a, b) => a.remainingMs - b.remainingMs);
+        return out.toSorted((a, b) => a.remainingMs - b.remainingMs);
     })();
     const checkStatus = (() => {
         const hasExpiredOrMissing = oauthProfiles.some((profile) => ["expired", "missing"].includes(profile.status)) ||
@@ -208,16 +218,25 @@ export async function modelsStatusCommand(opts, runtime) {
     if (opts.json) {
         runtime.log(JSON.stringify({
             configPath: CONFIG_PATH,
+            ...(agentId ? { agentId } : {}),
             agentDir,
             defaultModel: defaultLabel,
             resolvedDefault: resolvedLabel,
             fallbacks,
             imageModel: imageModel || null,
             imageFallbacks,
+            ...(agentId
+                ? {
+                    modelConfig: {
+                        defaultSource: agentModelPrimary ? "agent" : "defaults",
+                        fallbacksSource: agentFallbacksOverride !== undefined ? "agent" : "defaults",
+                    },
+                }
+                : {}),
             aliases,
             allowed,
             auth: {
-                storePath: resolveAuthStorePathForDisplay(),
+                storePath: resolveAuthStorePathForDisplay(agentDir),
                 shellEnvFallback: {
                     enabled: shellFallbackEnabled,
                     appliedKeys: applied,
@@ -246,13 +265,14 @@ export async function modelsStatusCommand(opts, runtime) {
     }
     const rich = isRich(opts);
     const label = (value) => colorize(rich, theme.accent, value.padEnd(14));
+    const labelWithSource = (value, source) => label(source ? `${value} (${source})` : value);
     const displayDefault = rawModel && rawModel !== resolvedLabel ? `${resolvedLabel} (from ${rawModel})` : resolvedLabel;
     runtime.log(`${label("Config")}${colorize(rich, theme.muted, ":")} ${colorize(rich, theme.info, shortenHomePath(CONFIG_PATH))}`);
     runtime.log(`${label("Agent dir")}${colorize(rich, theme.muted, ":")} ${colorize(rich, theme.info, shortenHomePath(agentDir))}`);
-    runtime.log(`${label("Default")}${colorize(rich, theme.muted, ":")} ${colorize(rich, theme.success, displayDefault)}`);
-    runtime.log(`${label(`Fallbacks (${fallbacks.length || 0})`)}${colorize(rich, theme.muted, ":")} ${colorize(rich, fallbacks.length ? theme.warn : theme.muted, fallbacks.length ? fallbacks.join(", ") : "-")}`);
-    runtime.log(`${label("Image model")}${colorize(rich, theme.muted, ":")} ${colorize(rich, imageModel ? theme.accentBright : theme.muted, imageModel || "-")}`);
-    runtime.log(`${label(`Image fallbacks (${imageFallbacks.length || 0})`)}${colorize(rich, theme.muted, ":")} ${colorize(rich, imageFallbacks.length ? theme.accentBright : theme.muted, imageFallbacks.length ? imageFallbacks.join(", ") : "-")}`);
+    runtime.log(`${labelWithSource("Default", agentId ? (agentModelPrimary ? "agent" : "defaults") : undefined)}${colorize(rich, theme.muted, ":")} ${colorize(rich, theme.success, displayDefault)}`);
+    runtime.log(`${labelWithSource(`Fallbacks (${fallbacks.length || 0})`, agentId ? (agentFallbacksOverride !== undefined ? "agent" : "defaults") : undefined)}${colorize(rich, theme.muted, ":")} ${colorize(rich, fallbacks.length ? theme.warn : theme.muted, fallbacks.length ? fallbacks.join(", ") : "-")}`);
+    runtime.log(`${labelWithSource("Image model", agentId ? "defaults" : undefined)}${colorize(rich, theme.muted, ":")} ${colorize(rich, imageModel ? theme.accentBright : theme.muted, imageModel || "-")}`);
+    runtime.log(`${labelWithSource(`Image fallbacks (${imageFallbacks.length || 0})`, agentId ? "defaults" : undefined)}${colorize(rich, theme.muted, ":")} ${colorize(rich, imageFallbacks.length ? theme.accentBright : theme.muted, imageFallbacks.length ? imageFallbacks.join(", ") : "-")}`);
     runtime.log(`${label(`Aliases (${Object.keys(aliases).length || 0})`)}${colorize(rich, theme.muted, ":")} ${colorize(rich, Object.keys(aliases).length ? theme.accent : theme.muted, Object.keys(aliases).length
         ? Object.entries(aliases)
             .map(([alias, target]) => rich

package/dist/commands/models/shared.js

@@ -1,6 +1,9 @@
+import { listAgentIds } from "../../agents/agent-scope.js";
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
 import { buildModelAliasIndex, modelKey, parseModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
+import { formatCliCommand } from "../../cli/command-format.js";
 import { readConfigFileSnapshot, writeConfigFile, } from "../../config/config.js";
+import { normalizeAgentId } from "../../routing/session-key.js";
 export const ensureFlagCompatibility = (opts) => {
     if (opts.json && opts.plain) {
         throw new Error("Choose either --json or --plain, not both.");
@@ -67,6 +70,18 @@ export function normalizeAlias(alias) {
     }
     return trimmed;
 }
+export function resolveKnownAgentId(params) {
+    const raw = params.rawAgentId?.trim();
+    if (!raw) {
+        return undefined;
+    }
+    const agentId = normalizeAgentId(raw);
+    const knownAgents = listAgentIds(params.cfg);
+    if (!knownAgents.includes(agentId)) {
+        throw new Error(`Unknown agent id "${raw}". Use "${formatCliCommand("poolbot agents list")}" to see configured agents.`);
+    }
+    return agentId;
+}
 export { modelKey };
 export { DEFAULT_MODEL, DEFAULT_PROVIDER };
 /**

package/dist/commands/onboard-custom.js

@@ -0,0 +1,384 @@
+import { DEFAULT_PROVIDER } from "../agents/defaults.js";
+import { buildModelAliasIndex, modelKey } from "../agents/model-selection.js";
+import { fetchWithTimeout } from "../utils/fetch-timeout.js";
+import { applyPrimaryModel } from "./model-picker.js";
+import { normalizeAlias } from "./models/shared.js";
+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 = 10000;
+const COMPATIBILITY_OPTIONS = [
+    {
+        value: "openai",
+        label: "OpenAI-compatible",
+        hint: "Uses /chat/completions",
+        api: "openai-completions",
+    },
+    {
+        value: "anthropic",
+        label: "Anthropic-compatible",
+        hint: "Uses /messages",
+        api: "anthropic-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);
+        const host = url.hostname.replace(/[^a-z0-9]+/gi, "-").toLowerCase();
+        const port = url.port ? `-${url.port}` : "";
+        const candidate = `custom-${host}${port}`;
+        return normalizeEndpointId(candidate) || "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 undefined;
+    }
+    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 undefined;
+    }
+    const existingKey = modelKey(existing.ref.provider, existing.ref.model);
+    if (existingKey === params.modelRef) {
+        return undefined;
+    }
+    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 undefined;
+            }
+            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() };
+}
+export 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() ? undefined : "Model ID is required"),
+    })).trim();
+    let compatibility = compatibilityChoice === "unknown" ? null : compatibilityChoice;
+    let providerApi = COMPATIBILITY_OPTIONS.find((entry) => entry.value === compatibility)?.api ??
+        "openai-completions";
+    while (true) {
+        let verifiedFromProbe = false;
+        if (!compatibility) {
+            const probeSpinner = prompter.progress("Detecting endpoint type...");
+            const openaiProbe = await requestOpenAiVerification({ baseUrl, apiKey, modelId });
+            if (openaiProbe.ok) {
+                probeSpinner.stop("Detected OpenAI-compatible endpoint.");
+                compatibility = "openai";
+                providerApi = "openai-completions";
+                verifiedFromProbe = true;
+            }
+            else {
+                const anthropicProbe = await requestAnthropicVerification({ baseUrl, apiKey, modelId });
+                if (anthropicProbe.ok) {
+                    probeSpinner.stop("Detected Anthropic-compatible endpoint.");
+                    compatibility = "anthropic";
+                    providerApi = "anthropic-messages";
+                    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() ? undefined : "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 !== undefined) {
+            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() ? undefined : "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) => {
+            const normalized = normalizeEndpointId(value);
+            if (!normalized) {
+                return "Endpoint ID is required.";
+            }
+            return undefined;
+        },
+    });
+    const providerIdResult = resolveUniqueEndpointId({
+        requestedId: providerIdInput,
+        baseUrl,
+        providers,
+    });
+    if (providerIdResult.renamed) {
+        await prompter.note(`Endpoint ID "${providerIdInput}" already exists for a different base URL. Using "${providerIdResult.providerId}".`, "Endpoint ID");
+    }
+    const providerId = providerIdResult.providerId;
+    const modelRef = modelKey(providerId, modelId);
+    const aliasInput = await prompter.text({
+        message: "Model alias (optional)",
+        placeholder: "e.g. local, ollama",
+        initialValue: "",
+        validate: (value) => resolveAliasError({ raw: value, cfg: config, modelRef }),
+    });
+    const alias = aliasInput.trim();
+    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 = apiKey.trim() || (existingApiKey ? existingApiKey.trim() : undefined);
+    let newConfig = {
+        ...config,
+        models: {
+            ...config.models,
+            mode: config.models?.mode ?? "merge",
+            providers: {
+                ...providers,
+                [providerId]: {
+                    ...existingProviderRest,
+                    baseUrl,
+                    api: providerApi,
+                    ...(normalizedApiKey ? { apiKey: normalizedApiKey } : {}),
+                    models: mergedModels.length > 0 ? mergedModels : [nextModel],
+                },
+            },
+        },
+    };
+    newConfig = applyPrimaryModel(newConfig, modelRef);
+    if (alias) {
+        newConfig = {
+            ...newConfig,
+            agents: {
+                ...newConfig.agents,
+                defaults: {
+                    ...newConfig.agents?.defaults,
+                    models: {
+                        ...newConfig.agents?.defaults?.models,
+                        [modelRef]: {
+                            ...newConfig.agents?.defaults?.models?.[modelRef],
+                            alias,
+                        },
+                    },
+                },
+            },
+        };
+    }
+    runtime.log(`Configured custom provider: ${providerId}/${modelId}`);
+    return { config: newConfig, providerId, modelId };
+}

package/dist/commands/onboard-non-interactive/local/auth-choice-inference.js

@@ -0,0 +1,35 @@
+const AUTH_CHOICE_FLAG_MAP = [
+    { flag: "anthropicApiKey", authChoice: "apiKey", label: "--anthropic-api-key" },
+    { flag: "geminiApiKey", authChoice: "gemini-api-key", label: "--gemini-api-key" },
+    { flag: "openaiApiKey", authChoice: "openai-api-key", label: "--openai-api-key" },
+    { flag: "openrouterApiKey", authChoice: "openrouter-api-key", label: "--openrouter-api-key" },
+    { flag: "aiGatewayApiKey", authChoice: "ai-gateway-api-key", label: "--ai-gateway-api-key" },
+    {
+        flag: "cloudflareAiGatewayApiKey",
+        authChoice: "cloudflare-ai-gateway-api-key",
+        label: "--cloudflare-ai-gateway-api-key",
+    },
+    { flag: "moonshotApiKey", authChoice: "moonshot-api-key", label: "--moonshot-api-key" },
+    { flag: "kimiCodeApiKey", authChoice: "kimi-code-api-key", label: "--kimi-code-api-key" },
+    { flag: "syntheticApiKey", authChoice: "synthetic-api-key", label: "--synthetic-api-key" },
+    { flag: "veniceApiKey", authChoice: "venice-api-key", label: "--venice-api-key" },
+    { flag: "zaiApiKey", authChoice: "zai-api-key", label: "--zai-api-key" },
+    { flag: "xiaomiApiKey", authChoice: "xiaomi-api-key", label: "--xiaomi-api-key" },
+    { flag: "xaiApiKey", authChoice: "xai-api-key", label: "--xai-api-key" },
+    { flag: "minimaxApiKey", authChoice: "minimax-api", label: "--minimax-api-key" },
+    { flag: "opencodeZenApiKey", authChoice: "opencode-zen", label: "--opencode-zen-api-key" },
+];
+// Infer auth choice from explicit provider API key flags.
+export function inferAuthChoiceFromFlags(opts) {
+    const matches = AUTH_CHOICE_FLAG_MAP.filter(({ flag }) => {
+        const value = opts[flag];
+        if (typeof value === "string") {
+            return value.trim().length > 0;
+        }
+        return Boolean(value);
+    });
+    return {
+        choice: matches[0]?.authChoice,
+        matches,
+    };
+}

package/dist/commands/onboard-non-interactive/local/auth-choice.js

@@ -2,8 +2,10 @@ import { upsertAuthProfile } from "../../../agents/auth-profiles.js";
 import { normalizeProviderId } from "../../../agents/model-selection.js";
 import { parseDurationMs } from "../../../cli/parse-duration.js";
 import { upsertSharedEnvVar } from "../../../infra/env-file.js";
+import { normalizeSecretInput } from "../../../utils/normalize-secret-input.js";
 import { buildTokenProfileId, validateAnthropicSetupToken } from "../../auth-token.js";
 import { applyGoogleGeminiModelDefault } from "../../google-gemini-model-default.js";
+import { applyOpenAIConfig } from "../../openai-model-default.js";
 import { applyAuthProfileConfig, applyCloudflareAiGatewayConfig, applyKimiCodeConfig, applyMinimaxApiConfig, applyMinimaxConfig, applyMoonshotConfig, applyMoonshotConfigCn, applyOpencodeZenConfig, applyOpenrouterConfig, applyQianfanConfig, applySyntheticConfig, applyTogetherConfig, applyVeniceConfig, applyVercelAiGatewayConfig, applyXaiConfig, applyXiaomiConfig, applyZaiConfig, setAnthropicApiKey, setCloudflareAiGatewayConfig, setGeminiApiKey, setKimiCodingApiKey, setMinimaxApiKey, setMoonshotApiKey, setOpencodeZenApiKey, setOpenrouterApiKey, setQianfanApiKey, setSyntheticApiKey, setTogetherApiKey, setVeniceApiKey, setVercelAiGatewayApiKey, setXaiApiKey, setXiaomiApiKey, setZaiApiKey, } from "../../onboard-auth.js";
 import { resolveNonInteractiveApiKey } from "../api-keys.js";
 import { shortenHomePath } from "../../../utils.js";
@@ -58,7 +60,7 @@ export async function applyNonInteractiveAuthChoice(params) {
             runtime.exit(1);
             return null;
         }
-        const tokenRaw = opts.token?.trim();
+        const tokenRaw = normalizeSecretInput(opts.token);
         if (!tokenRaw) {
             runtime.error("Missing --token for --auth-choice token.");
             runtime.exit(1);
@@ -154,7 +156,7 @@ export async function applyNonInteractiveAuthChoice(params) {
         const result = upsertSharedEnvVar({ key: "OPENAI_API_KEY", value: key });
         process.env.OPENAI_API_KEY = key;
         runtime.log(`Saved OPENAI_API_KEY to ${shortenHomePath(result.path)}`);
-        return nextConfig;
+        return applyOpenAIConfig(nextConfig);
     }
     if (authChoice === "openrouter-api-key") {
         const resolved = await resolveNonInteractiveApiKey({
@@ -458,7 +460,8 @@ export async function applyNonInteractiveAuthChoice(params) {
     if (authChoice === "oauth" ||
         authChoice === "chutes" ||
         authChoice === "openai-codex" ||
-        authChoice === "qwen-portal") {
+        authChoice === "qwen-portal" ||
+        authChoice === "minimax-portal") {
         runtime.error("OAuth requires interactive mode.");
         runtime.exit(1);
         return null;