@poolzin/pool-bot 2026.1.39 → 2026.2.0

package/dist/commands/auth-choice.apply.api-providers.js

@@ -3,14 +3,15 @@ import { resolveEnvApiKey } from "../agents/model-auth.js";
 import { formatApiKeyPreview, normalizeApiKeyInput, validateApiKeyInput, } from "./auth-choice.api-key.js";
 import { applyDefaultModelChoice } from "./auth-choice.default-model.js";
 import { applyGoogleGeminiModelDefault, GOOGLE_GEMINI_DEFAULT_MODEL, } from "./google-gemini-model-default.js";
-import { applyAuthProfileConfig, applyKimiCodeConfig, applyKimiCodeProviderConfig, applyMoonshotConfig, applyMoonshotProviderConfig, applyOpencodeZenConfig, applyOpencodeZenProviderConfig, applyOpenrouterConfig, applyOpenrouterProviderConfig, applySyntheticConfig, applySyntheticProviderConfig, applyVeniceConfig, applyVeniceProviderConfig, applyVercelAiGatewayConfig, applyVercelAiGatewayProviderConfig, applyZaiConfig, KIMI_CODE_MODEL_REF, MOONSHOT_DEFAULT_MODEL_REF, OPENROUTER_DEFAULT_MODEL_REF, SYNTHETIC_DEFAULT_MODEL_REF, VENICE_DEFAULT_MODEL_REF, VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, setGeminiApiKey, setKimiCodeApiKey, setMoonshotApiKey, setOpencodeZenApiKey, setOpenrouterApiKey, setSyntheticApiKey, setVeniceApiKey, setVercelAiGatewayApiKey, setZaiApiKey, ZAI_DEFAULT_MODEL_REF, } from "./onboard-auth.js";
+import { applyAuthProfileConfig, applyCloudflareAiGatewayConfig, applyCloudflareAiGatewayProviderConfig, applyQianfanConfig, applyQianfanProviderConfig, applyKimiCodeConfig, applyKimiCodeProviderConfig, applyMoonshotConfig, applyMoonshotConfigCn, applyMoonshotProviderConfig, applyMoonshotProviderConfigCn, applyOpencodeZenConfig, applyOpencodeZenProviderConfig, applyOpenrouterConfig, applyOpenrouterProviderConfig, applySyntheticConfig, applySyntheticProviderConfig, applyTogetherConfig, applyTogetherProviderConfig, applyVeniceConfig, applyVeniceProviderConfig, applyVercelAiGatewayConfig, applyVercelAiGatewayProviderConfig, applyXiaomiConfig, applyXiaomiProviderConfig, applyZaiConfig, CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, QIANFAN_DEFAULT_MODEL_REF, KIMI_CODING_MODEL_REF, MOONSHOT_DEFAULT_MODEL_REF, OPENROUTER_DEFAULT_MODEL_REF, SYNTHETIC_DEFAULT_MODEL_REF, TOGETHER_DEFAULT_MODEL_REF, VENICE_DEFAULT_MODEL_REF, VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, XIAOMI_DEFAULT_MODEL_REF, setCloudflareAiGatewayConfig, setQianfanApiKey, setGeminiApiKey, setKimiCodingApiKey, setMoonshotApiKey, setOpencodeZenApiKey, setOpenrouterApiKey, setSyntheticApiKey, setTogetherApiKey, setVeniceApiKey, setVercelAiGatewayApiKey, setXiaomiApiKey, setZaiApiKey, ZAI_DEFAULT_MODEL_REF, } from "./onboard-auth.js";
 import { OPENCODE_ZEN_DEFAULT_MODEL } from "./opencode-zen-model-default.js";
 export async function applyAuthChoiceApiProviders(params) {
     let nextConfig = params.config;
     let agentModelOverride;
     const noteAgentModel = async (model) => {
-        if (!params.agentId)
+        if (!params.agentId) {
             return;
+        }
         await params.prompter.note(`Default model set to ${model} for agent "${params.agentId}".`, "Model configured");
     };
     let authChoice = params.authChoice;
@@ -24,10 +25,14 @@ export async function applyAuthChoiceApiProviders(params) {
         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";
         }
-        else if (params.opts.tokenProvider === "kimi-code") {
+        else if (params.opts.tokenProvider === "kimi-code" ||
+            params.opts.tokenProvider === "kimi-coding") {
             authChoice = "kimi-code-api-key";
         }
         else if (params.opts.tokenProvider === "google") {
@@ -36,15 +41,24 @@ export async function applyAuthChoiceApiProviders(params) {
         else if (params.opts.tokenProvider === "zai") {
             authChoice = "zai-api-key";
         }
+        else if (params.opts.tokenProvider === "xiaomi") {
+            authChoice = "xiaomi-api-key";
+        }
         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 === "opencode") {
             authChoice = "opencode-zen";
         }
+        else if (params.opts.tokenProvider === "qianfan") {
+            authChoice = "qianfan-api-key";
+        }
     }
     if (authChoice === "openrouter-api-key") {
         const store = ensureAuthProfileStore(params.agentDir, {
@@ -165,6 +179,86 @@ export async function applyAuthChoiceApiProviders(params) {
         }
         return { config: nextConfig, agentModelOverride };
     }
+    if (authChoice === "cloudflare-ai-gateway-api-key") {
+        let hasCredential = false;
+        let accountId = params.opts?.cloudflareAiGatewayAccountId?.trim() ?? "";
+        let gatewayId = params.opts?.cloudflareAiGatewayGatewayId?.trim() ?? "";
+        const ensureAccountGateway = async () => {
+            if (!accountId) {
+                const value = await params.prompter.text({
+                    message: "Enter Cloudflare Account ID",
+                    validate: (val) => (String(val).trim() ? undefined : "Account ID is required"),
+                });
+                accountId = String(value).trim();
+            }
+            if (!gatewayId) {
+                const value = await params.prompter.text({
+                    message: "Enter Cloudflare AI Gateway ID",
+                    validate: (val) => (String(val).trim() ? undefined : "Gateway ID is required"),
+                });
+                gatewayId = String(value).trim();
+            }
+        };
+        const optsApiKey = normalizeApiKeyInput(params.opts?.cloudflareAiGatewayApiKey ?? "");
+        if (!hasCredential && accountId && gatewayId && optsApiKey) {
+            await setCloudflareAiGatewayConfig(accountId, gatewayId, optsApiKey, params.agentDir);
+            hasCredential = true;
+        }
+        const envKey = resolveEnvApiKey("cloudflare-ai-gateway");
+        if (!hasCredential && envKey) {
+            const useExisting = await params.prompter.confirm({
+                message: `Use existing CLOUDFLARE_AI_GATEWAY_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                initialValue: true,
+            });
+            if (useExisting) {
+                await ensureAccountGateway();
+                await setCloudflareAiGatewayConfig(accountId, gatewayId, normalizeApiKeyInput(envKey.apiKey), params.agentDir);
+                hasCredential = true;
+            }
+        }
+        if (!hasCredential && optsApiKey) {
+            await ensureAccountGateway();
+            await setCloudflareAiGatewayConfig(accountId, gatewayId, optsApiKey, params.agentDir);
+            hasCredential = true;
+        }
+        if (!hasCredential) {
+            await ensureAccountGateway();
+            const key = await params.prompter.text({
+                message: "Enter Cloudflare AI Gateway API key",
+                validate: validateApiKeyInput,
+            });
+            await setCloudflareAiGatewayConfig(accountId, gatewayId, normalizeApiKeyInput(String(key)), params.agentDir);
+            hasCredential = true;
+        }
+        if (hasCredential) {
+            nextConfig = applyAuthProfileConfig(nextConfig, {
+                profileId: "cloudflare-ai-gateway:default",
+                provider: "cloudflare-ai-gateway",
+                mode: "api_key",
+            });
+        }
+        {
+            const applied = await applyDefaultModelChoice({
+                config: nextConfig,
+                setDefaultModel: params.setDefaultModel,
+                defaultModel: CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF,
+                applyDefaultConfig: (cfg) => applyCloudflareAiGatewayConfig(cfg, {
+                    accountId: accountId || params.opts?.cloudflareAiGatewayAccountId,
+                    gatewayId: gatewayId || params.opts?.cloudflareAiGatewayGatewayId,
+                }),
+                applyProviderConfig: (cfg) => applyCloudflareAiGatewayProviderConfig(cfg, {
+                    accountId: accountId || params.opts?.cloudflareAiGatewayAccountId,
+                    gatewayId: gatewayId || params.opts?.cloudflareAiGatewayGatewayId,
+                }),
+                noteDefault: CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF,
+                noteAgentModel,
+                prompter: params.prompter,
+            });
+            nextConfig = applied.config;
+            agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+        }
+        return { config: nextConfig, agentModelOverride };
+    }
     if (authChoice === "moonshot-api-key") {
         let hasCredential = false;
         if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "moonshot") {
@@ -209,49 +303,96 @@ export async function applyAuthChoiceApiProviders(params) {
         }
         return { config: nextConfig, agentModelOverride };
     }
+    if (authChoice === "moonshot-api-key-cn") {
+        let hasCredential = false;
+        if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "moonshot") {
+            await setMoonshotApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+            hasCredential = true;
+        }
+        const envKey = resolveEnvApiKey("moonshot");
+        if (envKey) {
+            const useExisting = await params.prompter.confirm({
+                message: `Use existing MOONSHOT_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                initialValue: true,
+            });
+            if (useExisting) {
+                await setMoonshotApiKey(envKey.apiKey, params.agentDir);
+                hasCredential = true;
+            }
+        }
+        if (!hasCredential) {
+            const key = await params.prompter.text({
+                message: "Enter Moonshot API key (.cn)",
+                validate: validateApiKeyInput,
+            });
+            await setMoonshotApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+        }
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId: "moonshot:default",
+            provider: "moonshot",
+            mode: "api_key",
+        });
+        {
+            const applied = await applyDefaultModelChoice({
+                config: nextConfig,
+                setDefaultModel: params.setDefaultModel,
+                defaultModel: MOONSHOT_DEFAULT_MODEL_REF,
+                applyDefaultConfig: applyMoonshotConfigCn,
+                applyProviderConfig: applyMoonshotProviderConfigCn,
+                noteAgentModel,
+                prompter: params.prompter,
+            });
+            nextConfig = applied.config;
+            agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+        }
+        return { config: nextConfig, agentModelOverride };
+    }
     if (authChoice === "kimi-code-api-key") {
         let hasCredential = false;
-        if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "kimi-code") {
-            await setKimiCodeApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+        const tokenProvider = params.opts?.tokenProvider?.trim().toLowerCase();
+        if (!hasCredential &&
+            params.opts?.token &&
+            (tokenProvider === "kimi-code" || tokenProvider === "kimi-coding")) {
+            await setKimiCodingApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
             hasCredential = true;
         }
         if (!hasCredential) {
             await params.prompter.note([
-                "Kimi Code uses a dedicated endpoint and API key.",
+                "Kimi Coding uses a dedicated endpoint and API key.",
                 "Get your API key at: https://www.kimi.com/code/en",
-            ].join("\n"), "Kimi Code");
+            ].join("\n"), "Kimi Coding");
         }
-        const envKey = resolveEnvApiKey("kimi-code");
+        const envKey = resolveEnvApiKey("kimi-coding");
         if (envKey) {
             const useExisting = await params.prompter.confirm({
-                message: `Use existing KIMICODE_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                message: `Use existing KIMI_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
                 initialValue: true,
             });
             if (useExisting) {
-                await setKimiCodeApiKey(envKey.apiKey, params.agentDir);
+                await setKimiCodingApiKey(envKey.apiKey, params.agentDir);
                 hasCredential = true;
             }
         }
         if (!hasCredential) {
             const key = await params.prompter.text({
-                message: "Enter Kimi Code API key",
+                message: "Enter Kimi Coding API key",
                 validate: validateApiKeyInput,
             });
-            await setKimiCodeApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+            await setKimiCodingApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
         }
         nextConfig = applyAuthProfileConfig(nextConfig, {
-            profileId: "kimi-code:default",
-            provider: "kimi-code",
+            profileId: "kimi-coding:default",
+            provider: "kimi-coding",
             mode: "api_key",
         });
         {
             const applied = await applyDefaultModelChoice({
                 config: nextConfig,
                 setDefaultModel: params.setDefaultModel,
-                defaultModel: KIMI_CODE_MODEL_REF,
+                defaultModel: KIMI_CODING_MODEL_REF,
                 applyDefaultConfig: applyKimiCodeConfig,
                 applyProviderConfig: applyKimiCodeProviderConfig,
-                noteDefault: KIMI_CODE_MODEL_REF,
+                noteDefault: KIMI_CODING_MODEL_REF,
                 noteAgentModel,
                 prompter: params.prompter,
             });
@@ -362,6 +503,51 @@ export async function applyAuthChoiceApiProviders(params) {
         }
         return { config: nextConfig, agentModelOverride };
     }
+    if (authChoice === "xiaomi-api-key") {
+        let hasCredential = false;
+        if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "xiaomi") {
+            await setXiaomiApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+            hasCredential = true;
+        }
+        const envKey = resolveEnvApiKey("xiaomi");
+        if (envKey) {
+            const useExisting = await params.prompter.confirm({
+                message: `Use existing XIAOMI_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                initialValue: true,
+            });
+            if (useExisting) {
+                await setXiaomiApiKey(envKey.apiKey, params.agentDir);
+                hasCredential = true;
+            }
+        }
+        if (!hasCredential) {
+            const key = await params.prompter.text({
+                message: "Enter Xiaomi API key",
+                validate: validateApiKeyInput,
+            });
+            await setXiaomiApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+        }
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId: "xiaomi:default",
+            provider: "xiaomi",
+            mode: "api_key",
+        });
+        {
+            const applied = await applyDefaultModelChoice({
+                config: nextConfig,
+                setDefaultModel: params.setDefaultModel,
+                defaultModel: XIAOMI_DEFAULT_MODEL_REF,
+                applyDefaultConfig: applyXiaomiConfig,
+                applyProviderConfig: applyXiaomiProviderConfig,
+                noteDefault: XIAOMI_DEFAULT_MODEL_REF,
+                noteAgentModel,
+                prompter: params.prompter,
+            });
+            nextConfig = applied.config;
+            agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+        }
+        return { config: nextConfig, agentModelOverride };
+    }
     if (authChoice === "synthetic-api-key") {
         if (params.opts?.token && params.opts?.tokenProvider === "synthetic") {
             await setSyntheticApiKey(String(params.opts.token).trim(), params.agentDir);
@@ -456,7 +642,7 @@ export async function applyAuthChoiceApiProviders(params) {
             await params.prompter.note([
                 "OpenCode Zen provides access to Claude, GPT, Gemini, and more models.",
                 "Get your API key at: https://opencode.ai/auth",
-                "Requires an active OpenCode Zen subscription.",
+                "OpenCode Zen bills per request. Check your OpenCode dashboard for details.",
             ].join("\n"), "OpenCode Zen");
         }
         const envKey = resolveEnvApiKey("opencode");
@@ -498,5 +684,107 @@ export async function applyAuthChoiceApiProviders(params) {
         }
         return { config: nextConfig, agentModelOverride };
     }
+    if (authChoice === "together-api-key") {
+        let hasCredential = false;
+        if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "together") {
+            await setTogetherApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+            hasCredential = true;
+        }
+        if (!hasCredential) {
+            await params.prompter.note([
+                "Together AI provides access to leading open-source models including Llama, DeepSeek, Qwen, and more.",
+                "Get your API key at: https://api.together.xyz/settings/api-keys",
+            ].join("\n"), "Together AI");
+        }
+        const envKey = resolveEnvApiKey("together");
+        if (envKey) {
+            const useExisting = await params.prompter.confirm({
+                message: `Use existing TOGETHER_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                initialValue: true,
+            });
+            if (useExisting) {
+                await setTogetherApiKey(envKey.apiKey, params.agentDir);
+                hasCredential = true;
+            }
+        }
+        if (!hasCredential) {
+            const key = await params.prompter.text({
+                message: "Enter Together AI API key",
+                validate: validateApiKeyInput,
+            });
+            await setTogetherApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+        }
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId: "together:default",
+            provider: "together",
+            mode: "api_key",
+        });
+        {
+            const applied = await applyDefaultModelChoice({
+                config: nextConfig,
+                setDefaultModel: params.setDefaultModel,
+                defaultModel: TOGETHER_DEFAULT_MODEL_REF,
+                applyDefaultConfig: applyTogetherConfig,
+                applyProviderConfig: applyTogetherProviderConfig,
+                noteDefault: TOGETHER_DEFAULT_MODEL_REF,
+                noteAgentModel,
+                prompter: params.prompter,
+            });
+            nextConfig = applied.config;
+            agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+        }
+        return { config: nextConfig, agentModelOverride };
+    }
+    if (authChoice === "qianfan-api-key") {
+        let hasCredential = false;
+        if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "qianfan") {
+            setQianfanApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+            hasCredential = true;
+        }
+        if (!hasCredential) {
+            await params.prompter.note([
+                "Get your API key at: https://console.bce.baidu.com/qianfan/ais/console/apiKey",
+                "API key format: bce-v3/ALTAK-...",
+            ].join("\n"), "QIANFAN");
+        }
+        const envKey = resolveEnvApiKey("qianfan");
+        if (envKey) {
+            const useExisting = await params.prompter.confirm({
+                message: `Use existing QIANFAN_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                initialValue: true,
+            });
+            if (useExisting) {
+                setQianfanApiKey(envKey.apiKey, params.agentDir);
+                hasCredential = true;
+            }
+        }
+        if (!hasCredential) {
+            const key = await params.prompter.text({
+                message: "Enter QIANFAN API key",
+                validate: validateApiKeyInput,
+            });
+            setQianfanApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+        }
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId: "qianfan:default",
+            provider: "qianfan",
+            mode: "api_key",
+        });
+        {
+            const applied = await applyDefaultModelChoice({
+                config: nextConfig,
+                setDefaultModel: params.setDefaultModel,
+                defaultModel: QIANFAN_DEFAULT_MODEL_REF,
+                applyDefaultConfig: applyQianfanConfig,
+                applyProviderConfig: applyQianfanProviderConfig,
+                noteDefault: QIANFAN_DEFAULT_MODEL_REF,
+                noteAgentModel,
+                prompter: params.prompter,
+            });
+            nextConfig = applied.config;
+            agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+        }
+        return { config: nextConfig, agentModelOverride };
+    }
     return null;
 }

package/dist/commands/auth-choice.apply.js

@@ -8,6 +8,7 @@ import { applyAuthChoiceMiniMax } from "./auth-choice.apply.minimax.js";
 import { applyAuthChoiceOAuth } from "./auth-choice.apply.oauth.js";
 import { applyAuthChoiceOpenAI } from "./auth-choice.apply.openai.js";
 import { applyAuthChoiceQwenPortal } from "./auth-choice.apply.qwen-portal.js";
+import { applyAuthChoiceXAI } from "./auth-choice.apply.xai.js";
 export async function applyAuthChoice(params) {
     const handlers = [
         applyAuthChoiceAnthropic,
@@ -20,11 +21,13 @@ export async function applyAuthChoice(params) {
         applyAuthChoiceGoogleGeminiCli,
         applyAuthChoiceCopilotProxy,
         applyAuthChoiceQwenPortal,
+        applyAuthChoiceXAI,
     ];
     for (const handler of handlers) {
         const result = await handler(params);
-        if (result)
+        if (result) {
             return result;
+        }
     }
     return { config: params.config };
 }

package/dist/commands/auth-choice.apply.plugin-provider.js

@@ -1,4 +1,4 @@
-import { resolveMoltbotAgentDir } from "../agents/agent-paths.js";
+import { resolvePoolbotAgentDir } from "../agents/agent-paths.js";
 import { resolveDefaultAgentId, resolveAgentDir, resolveAgentWorkspaceDir, } from "../agents/agent-scope.js";
 import { upsertAuthProfile } from "../agents/auth-profiles.js";
 import { normalizeProviderId } from "../agents/model-selection.js";
@@ -76,7 +76,7 @@ export async function applyAuthChoicePluginProvider(params, options) {
     const agentId = params.agentId ?? resolveDefaultAgentId(nextConfig);
     const defaultAgentId = resolveDefaultAgentId(nextConfig);
     const agentDir = params.agentDir ??
-        (agentId === defaultAgentId ? resolveMoltbotAgentDir() : resolveAgentDir(nextConfig, agentId));
+        (agentId === defaultAgentId ? resolvePoolbotAgentDir() : resolveAgentDir(nextConfig, agentId));
     const workspaceDir = resolveAgentWorkspaceDir(nextConfig, agentId) ?? resolveDefaultAgentWorkspaceDir();
     const providers = resolvePluginProviders({ config: nextConfig, workspaceDir });
     const provider = resolveProviderMatch(providers, options.providerId);

package/dist/commands/auth-choice.apply.xai.js

@@ -0,0 +1,63 @@
+import { resolveEnvApiKey } from "../agents/model-auth.js";
+import { formatApiKeyPreview, normalizeApiKeyInput, validateApiKeyInput, } from "./auth-choice.api-key.js";
+import { applyDefaultModelChoice } from "./auth-choice.default-model.js";
+import { applyAuthProfileConfig, applyXaiConfig, applyXaiProviderConfig, setXaiApiKey, XAI_DEFAULT_MODEL_REF, } from "./onboard-auth.js";
+export async function applyAuthChoiceXAI(params) {
+    if (params.authChoice !== "xai-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;
+    const optsKey = params.opts?.xaiApiKey?.trim();
+    if (optsKey) {
+        setXaiApiKey(normalizeApiKeyInput(optsKey), params.agentDir);
+        hasCredential = true;
+    }
+    if (!hasCredential) {
+        const envKey = resolveEnvApiKey("xai");
+        if (envKey) {
+            const useExisting = await params.prompter.confirm({
+                message: `Use existing XAI_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                initialValue: true,
+            });
+            if (useExisting) {
+                setXaiApiKey(envKey.apiKey, params.agentDir);
+                hasCredential = true;
+            }
+        }
+    }
+    if (!hasCredential) {
+        const key = await params.prompter.text({
+            message: "Enter xAI API key",
+            validate: validateApiKeyInput,
+        });
+        setXaiApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+    }
+    nextConfig = applyAuthProfileConfig(nextConfig, {
+        profileId: "xai:default",
+        provider: "xai",
+        mode: "api_key",
+    });
+    {
+        const applied = await applyDefaultModelChoice({
+            config: nextConfig,
+            setDefaultModel: params.setDefaultModel,
+            defaultModel: XAI_DEFAULT_MODEL_REF,
+            applyDefaultConfig: applyXaiConfig,
+            applyProviderConfig: applyXaiProviderConfig,
+            noteDefault: XAI_DEFAULT_MODEL_REF,
+            noteAgentModel,
+            prompter: params.prompter,
+        });
+        nextConfig = applied.config;
+        agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+    }
+    return { config: nextConfig, agentModelOverride };
+}

package/dist/commands/auth-choice.preferred-provider.js

@@ -10,14 +10,18 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
     "openai-api-key": "openai",
     "openrouter-api-key": "openrouter",
     "ai-gateway-api-key": "vercel-ai-gateway",
+    "cloudflare-ai-gateway-api-key": "cloudflare-ai-gateway",
     "moonshot-api-key": "moonshot",
-    "kimi-code-api-key": "kimi-code",
+    "moonshot-api-key-cn": "moonshot",
+    "kimi-code-api-key": "kimi-coding",
     "gemini-api-key": "google",
     "google-antigravity": "google-antigravity",
     "google-gemini-cli": "google-gemini-cli",
     "zai-api-key": "zai",
+    "xiaomi-api-key": "xiaomi",
     "synthetic-api-key": "synthetic",
     "venice-api-key": "venice",
+    "together-api-key": "together",
     "github-copilot": "github-copilot",
     "copilot-proxy": "copilot-proxy",
     "minimax-cloud": "minimax",
@@ -25,7 +29,9 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
     "minimax-api-lightning": "minimax",
     minimax: "lmstudio",
     "opencode-zen": "opencode",
+    "xai-api-key": "xai",
     "qwen-portal": "qwen-portal",
+    "qianfan-api-key": "qianfan",
 };
 export function resolvePreferredProviderForAuthChoice(choice) {
     return PREFERRED_PROVIDER_BY_AUTH_CHOICE[choice];

package/dist/commands/configure.wizard.js

@@ -109,7 +109,7 @@ async function promptWebToolsConfig(nextConfig, runtime) {
 export async function runConfigureWizard(opts, runtime = defaultRuntime) {
     try {
         printWizardHeader(runtime);
-        intro(opts.command === "update" ? "Moltbot update wizard" : "Moltbot configure");
+        intro(opts.command === "update" ? "Poolbot update wizard" : "Poolbot configure");
         const prompter = createClackPrompter();
         const snapshot = await readConfigFileSnapshot();
         const baseConfig = snapshot.valid ? snapshot.config : {};

package/dist/commands/dashboard.js

@@ -39,7 +39,7 @@ export async function dashboardCommand(runtime = defaultRuntime, options = {}) {
         hint = "Browser launch disabled (--no-open). Use the URL above.";
     }
     if (opened) {
-        runtime.log("Opened in your browser. Keep that tab to control Moltbot.");
+        runtime.log("Opened in your browser. Keep that tab to control Poolbot.");
     }
     else if (hint) {
         runtime.log(hint);

package/dist/commands/docs.js

@@ -3,7 +3,7 @@ import { runCommandWithTimeout } from "../process/exec.js";
 import { formatDocsLink } from "../terminal/links.js";
 import { isRich, theme } from "../terminal/theme.js";
 import { formatCliCommand } from "../cli/command-format.js";
-const SEARCH_TOOL = "https://docs.molt.bot/mcp.SearchMoltbot";
+const SEARCH_TOOL = "https://docs.molt.bot/mcp.SearchPoolbot";
 const SEARCH_TIMEOUT_MS = 30_000;
 const DEFAULT_SNIPPET_MAX = 220;
 function resolveNodeRunner() {

package/dist/commands/doctor-gateway-services.js

@@ -36,7 +36,7 @@ export async function maybeMigrateLegacyGatewayService(cfg, mode, runtime, promp
         return;
     note(legacyServices.map((svc) => `- ${svc.label} (${svc.platform}, ${svc.detail})`).join("\n"), "Legacy gateway services detected");
     const migrate = await prompter.confirmSkipInNonInteractive({
-        message: "Migrate legacy gateway services to Moltbot now?",
+        message: "Migrate legacy gateway services to Poolbot now?",
         initialValue: true,
     });
     if (!migrate)
@@ -62,11 +62,11 @@ export async function maybeMigrateLegacyGatewayService(cfg, mode, runtime, promp
     const service = resolveGatewayService();
     const loaded = await service.isLoaded({ env: process.env });
     if (loaded) {
-        note(`Moltbot ${service.label} already ${service.loadedText}.`, "Gateway");
+        note(`Poolbot ${service.label} already ${service.loadedText}.`, "Gateway");
         return;
     }
     const install = await prompter.confirmSkipInNonInteractive({
-        message: "Install Moltbot gateway service now?",
+        message: "Install Poolbot gateway service now?",
         initialValue: true,
     });
     if (!install)

package/dist/commands/doctor-update.js

@@ -3,7 +3,7 @@ import { isTruthyEnvValue } from "../infra/env.js";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { note } from "../terminal/note.js";
 import { formatCliCommand } from "../cli/command-format.js";
-async function detectMoltbotGitCheckout(root) {
+async function detectPoolbotGitCheckout(root) {
     const res = await runCommandWithTimeout(["git", "-C", root, "rev-parse", "--show-toplevel"], {
         timeoutMs: 5000,
     }).catch(() => null);
@@ -28,10 +28,10 @@ export async function maybeOfferUpdateBeforeDoctor(params) {
         Boolean(process.stdin.isTTY);
     if (!canOfferUpdate || !params.root)
         return { updated: false };
-    const git = await detectMoltbotGitCheckout(params.root);
+    const git = await detectPoolbotGitCheckout(params.root);
     if (git === "git") {
         const shouldUpdate = await params.confirm({
-            message: "Update Moltbot from git before running doctor?",
+            message: "Update Poolbot from git before running doctor?",
             initialValue: true,
         });
         if (!shouldUpdate)

package/dist/commands/doctor.js

@@ -41,7 +41,7 @@ function resolveMode(cfg) {
 export async function doctorCommand(runtime = defaultRuntime, options = {}) {
     const prompter = createDoctorPrompter({ runtime, options });
     printWizardHeader(runtime);
-    intro("Moltbot doctor");
+    intro("Poolbot doctor");
     const root = await resolvePoolBotPackageRoot({
         moduleUrl: import.meta.url,
         argv1: process.argv[1],

package/dist/commands/models/list.probe.js

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
-import { resolveMoltbotAgentDir } from "../../agents/agent-paths.js";
+import { resolvePoolbotAgentDir } from "../../agents/agent-paths.js";
 import { ensureAuthProfileStore, listProfilesForProvider, resolveAuthProfileDisplayLabel, resolveAuthProfileOrder, } from "../../agents/auth-profiles.js";
 import { runEmbeddedPiAgent } from "../../agents/pi-embedded.js";
 import { describeFailoverError } from "../../agents/failover-error.js";
@@ -250,7 +250,7 @@ async function runTargetsWithConcurrency(params) {
     const { cfg, targets, timeoutMs, maxTokens, onProgress } = params;
     const concurrency = Math.max(1, Math.min(targets.length || 1, params.concurrency));
     const agentId = resolveDefaultAgentId(cfg);
-    const agentDir = resolveMoltbotAgentDir();
+    const agentDir = resolvePoolbotAgentDir();
     const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId) ?? resolveDefaultAgentWorkspaceDir();
     const sessionDir = resolveSessionTranscriptsDirForAgent(agentId);
     await fs.mkdir(workspaceDir, { recursive: true });