@poolzin/pool-bot 2026.2.4 → 2026.2.6

package/dist/commands/onboard-custom.js

@@ -7,18 +7,24 @@ 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;
+export class CustomApiError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "CustomApiError";
+        this.code = code;
+    }
+}
 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",
@@ -183,6 +189,155 @@ async function promptBaseUrlAndKey(params) {
     });
     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;
+}
+export 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",
+            }
+            : {}),
+    };
+}
+export 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 } : {}),
+    };
+}
+export 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() : undefined);
+    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 }
+            : {}),
+    };
+}
 export async function promptCustomApiConfig(params) {
     const { prompter, runtime, config } = params;
     const baseInput = await promptBaseUrlAndKey({ prompter });
@@ -202,8 +357,6 @@ export async function promptCustomApiConfig(params) {
         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) {
@@ -212,7 +365,6 @@ export async function promptCustomApiConfig(params) {
             if (openaiProbe.ok) {
                 probeSpinner.stop("Detected OpenAI-compatible endpoint.");
                 compatibility = "openai";
-                providerApi = "openai-completions";
                 verifiedFromProbe = true;
             }
             else {
@@ -220,7 +372,6 @@ export async function promptCustomApiConfig(params) {
                 if (anthropicProbe.ok) {
                     probeSpinner.stop("Detected Anthropic-compatible endpoint.");
                     compatibility = "anthropic";
-                    providerApi = "anthropic-messages";
                     verifiedFromProbe = true;
                 }
                 else {
@@ -311,74 +462,34 @@ export async function promptCustomApiConfig(params) {
             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],
-                },
-            },
+        validate: (value) => {
+            const requestedId = normalizeEndpointId(providerIdInput) || "custom";
+            const providerIdResult = resolveUniqueEndpointId({
+                requestedId,
+                baseUrl,
+                providers,
+            });
+            const modelRef = modelKey(providerIdResult.providerId, modelId);
+            return resolveAliasError({ raw: value, cfg: config, modelRef });
         },
-    };
-    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,
-                        },
-                    },
-                },
-            },
-        };
+    });
+    const resolvedCompatibility = compatibility ?? "openai";
+    const result = applyCustomApiConfig({
+        config,
+        baseUrl,
+        modelId,
+        compatibility: resolvedCompatibility,
+        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: ${providerId}/${modelId}`);
-    return { config: newConfig, providerId, modelId };
+    runtime.log(`Configured custom provider: ${result.providerId}/${result.modelId}`);
+    return result;
 }

package/dist/commands/onboard-non-interactive/api-keys.js

@@ -1,5 +1,6 @@
 import { ensureAuthProfileStore, resolveApiKeyForProfile, resolveAuthProfileOrder, } from "../../agents/auth-profiles.js";
 import { resolveEnvApiKey } from "../../agents/model-auth.js";
+import { normalizeOptionalSecretInput } from "../../utils/normalize-secret-input.js";
 async function resolveApiKeyFromProfiles(params) {
     const store = ensureAuthProfileStore(params.agentDir);
     const order = resolveAuthProfileOrder({
@@ -23,12 +24,18 @@ async function resolveApiKeyFromProfiles(params) {
     return null;
 }
 export async function resolveNonInteractiveApiKey(params) {
-    const flagKey = params.flagValue?.trim();
+    const flagKey = normalizeOptionalSecretInput(params.flagValue);
     if (flagKey)
         return { key: flagKey, source: "flag" };
     const envResolved = resolveEnvApiKey(params.provider);
     if (envResolved?.apiKey)
         return { key: envResolved.apiKey, source: "env" };
+    const explicitEnvVar = params.envVarName?.trim();
+    if (explicitEnvVar) {
+        const explicitEnvKey = normalizeOptionalSecretInput(process.env[explicitEnvVar]);
+        if (explicitEnvKey)
+            return { key: explicitEnvKey, source: "env" };
+    }
     if (params.allowProfile ?? true) {
         const profileKey = await resolveApiKeyFromProfiles({
             provider: params.provider,
@@ -38,6 +45,8 @@ export async function resolveNonInteractiveApiKey(params) {
         if (profileKey)
             return { key: profileKey, source: "profile" };
     }
+    if (params.required === false)
+        return null;
     const profileHint = params.allowProfile === false ? "" : `, or existing ${params.provider} API-key profile`;
     params.runtime.error(`Missing ${params.flagName} (or ${params.envVar} in env${profileHint}).`);
     params.runtime.exit(1);

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

@@ -13,21 +13,29 @@ const AUTH_CHOICE_FLAG_MAP = [
     { 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: "togetherApiKey", authChoice: "together-api-key", label: "--together-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: "nvidiaApiKey", authChoice: "nvidia-api-key", label: "--nvidia-api-key" },
+    { flag: "huggingfaceApiKey", authChoice: "huggingface-api-key", label: "--huggingface-api-key" },
+    { flag: "litellmApiKey", authChoice: "litellm-api-key", label: "--litellm-api-key" },
     { flag: "minimaxApiKey", authChoice: "minimax-api", label: "--minimax-api-key" },
     { flag: "opencodeZenApiKey", authChoice: "opencode-zen", label: "--opencode-zen-api-key" },
 ];
+function hasStringValue(val) {
+    return typeof val === "string" && val.trim().length > 0;
+}
 // 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);
-    });
+    const matches = AUTH_CHOICE_FLAG_MAP.filter(({ flag }) => hasStringValue(opts[flag]));
+    // Special case: custom-api-key is inferred from custom flags
+    if (!matches.length &&
+        (hasStringValue(opts.customBaseUrl) ||
+            hasStringValue(opts.customModelId) ||
+            hasStringValue(opts.customApiKey))) {
+        return { choice: "custom-api-key", matches: [] };
+    }
     return {
         choice: matches[0]?.authChoice,
         matches,