@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/commands/onboard-auth.models.js

@@ -1,3 +1,4 @@
+import { QIANFAN_BASE_URL, QIANFAN_DEFAULT_MODEL_ID } from "../agents/models-config.providers.js";
 export const DEFAULT_MINIMAX_BASE_URL = "https://api.minimax.io/v1";
 export const MINIMAX_API_BASE_URL = "https://api.minimax.io/anthropic";
 export const MINIMAX_HOSTED_MODEL_ID = "MiniMax-M2.1";
@@ -5,17 +6,15 @@ export const MINIMAX_HOSTED_MODEL_REF = `minimax/${MINIMAX_HOSTED_MODEL_ID}`;
 export const DEFAULT_MINIMAX_CONTEXT_WINDOW = 200000;
 export const DEFAULT_MINIMAX_MAX_TOKENS = 8192;
 export const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
-export const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2-0905-preview";
+export const MOONSHOT_CN_BASE_URL = "https://api.moonshot.cn/v1";
+export const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2.5";
 export const MOONSHOT_DEFAULT_MODEL_REF = `moonshot/${MOONSHOT_DEFAULT_MODEL_ID}`;
 export const MOONSHOT_DEFAULT_CONTEXT_WINDOW = 256000;
 export const MOONSHOT_DEFAULT_MAX_TOKENS = 8192;
-export const KIMI_CODE_BASE_URL = "https://api.kimi.com/coding/v1";
-export const KIMI_CODE_MODEL_ID = "kimi-for-coding";
-export const KIMI_CODE_MODEL_REF = `kimi-code/${KIMI_CODE_MODEL_ID}`;
-export const KIMI_CODE_CONTEXT_WINDOW = 262144;
-export const KIMI_CODE_MAX_TOKENS = 32768;
-export const KIMI_CODE_HEADERS = { "User-Agent": "KimiCLI/0.77" };
-export const KIMI_CODE_COMPAT = { supportsDeveloperRole: false };
+export const KIMI_CODING_MODEL_ID = "k2p5";
+export const KIMI_CODING_MODEL_REF = `kimi-coding/${KIMI_CODING_MODEL_ID}`;
+export { QIANFAN_BASE_URL, QIANFAN_DEFAULT_MODEL_ID };
+export const QIANFAN_DEFAULT_MODEL_REF = `qianfan/${QIANFAN_DEFAULT_MODEL_ID}`;
 // Pricing: MiniMax doesn't publish public rates. Override in models.json for accurate costs.
 export const MINIMAX_API_COST = {
     input: 15,
@@ -41,12 +40,6 @@ export const MOONSHOT_DEFAULT_COST = {
     cacheRead: 0,
     cacheWrite: 0,
 };
-export const KIMI_CODE_DEFAULT_COST = {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-};
 const MINIMAX_MODEL_CATALOG = {
     "MiniMax-M2.1": { name: "MiniMax M2.1", reasoning: false },
     "MiniMax-M2.1-lightning": {
@@ -77,7 +70,7 @@ export function buildMinimaxApiModelDefinition(modelId) {
 export function buildMoonshotModelDefinition() {
     return {
         id: MOONSHOT_DEFAULT_MODEL_ID,
-        name: "Kimi K2 0905 Preview",
+        name: "Kimi K2.5",
         reasoning: false,
         input: ["text"],
         cost: MOONSHOT_DEFAULT_COST,
@@ -85,16 +78,25 @@ export function buildMoonshotModelDefinition() {
         maxTokens: MOONSHOT_DEFAULT_MAX_TOKENS,
     };
 }
-export function buildKimiCodeModelDefinition() {
+export const XAI_BASE_URL = "https://api.x.ai/v1";
+export const XAI_DEFAULT_MODEL_ID = "grok-4";
+export const XAI_DEFAULT_MODEL_REF = `xai/${XAI_DEFAULT_MODEL_ID}`;
+export const XAI_DEFAULT_CONTEXT_WINDOW = 131072;
+export const XAI_DEFAULT_MAX_TOKENS = 8192;
+export const XAI_DEFAULT_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+export function buildXaiModelDefinition() {
     return {
-        id: KIMI_CODE_MODEL_ID,
-        name: "Kimi For Coding",
-        reasoning: true,
+        id: XAI_DEFAULT_MODEL_ID,
+        name: "Grok 4",
+        reasoning: false,
         input: ["text"],
-        cost: KIMI_CODE_DEFAULT_COST,
-        contextWindow: KIMI_CODE_CONTEXT_WINDOW,
-        maxTokens: KIMI_CODE_MAX_TOKENS,
-        headers: KIMI_CODE_HEADERS,
-        compat: KIMI_CODE_COMPAT,
+        cost: XAI_DEFAULT_COST,
+        contextWindow: XAI_DEFAULT_CONTEXT_WINDOW,
+        maxTokens: XAI_DEFAULT_MAX_TOKENS,
     };
 }

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,
+    };
+}