@poolzin/pool-bot 2026.1.38 → 2026.2.0

package/dist/cli/update-cli.js

@@ -317,7 +317,7 @@ export async function updateStatusCommand(opts) {
             Value: updateAvailability.available ? theme.warn(`available · ${updateLine}`) : updateLine,
         },
     ];
-    defaultRuntime.log(theme.heading("Moltbot update status"));
+    defaultRuntime.log(theme.heading("Poolbot update status"));
     defaultRuntime.log("");
     defaultRuntime.log(renderTable({
         width: tableWidth,
@@ -540,7 +540,7 @@ export async function updateCommand(opts) {
     }
     const showProgress = !opts.json && process.stdout.isTTY;
     if (!opts.json) {
-        defaultRuntime.log(theme.heading("Updating Moltbot..."));
+        defaultRuntime.log(theme.heading("Updating Poolbot..."));
         defaultRuntime.log("");
     }
     const { progress, stop } = createUpdateProgress(showProgress);
@@ -666,7 +666,7 @@ export async function updateCommand(opts) {
             defaultRuntime.log(theme.warn("Skipped: working directory has uncommitted changes. Commit or stash them first."));
         }
         if (result.reason === "not-git-install") {
-            defaultRuntime.log(theme.warn(`Skipped: this Moltbot install isn't a git checkout, and the package manager couldn't be detected. Update via your package manager, then run \`${replaceCliName(formatCliCommand("poolbot doctor"), CLI_NAME)}\` and \`${replaceCliName(formatCliCommand("poolbot gateway restart"), CLI_NAME)}\`.`));
+            defaultRuntime.log(theme.warn(`Skipped: this Poolbot install isn't a git checkout, and the package manager couldn't be detected. Update via your package manager, then run \`${replaceCliName(formatCliCommand("poolbot doctor"), CLI_NAME)}\` and \`${replaceCliName(formatCliCommand("poolbot gateway restart"), CLI_NAME)}\`.`));
             defaultRuntime.log(theme.muted(`Examples: \`${replaceCliName("npm i -g poolbot@latest", CLI_NAME)}\` or \`${replaceCliName("pnpm add -g poolbot@latest", CLI_NAME)}\``));
         }
         defaultRuntime.exit(0);
@@ -911,7 +911,7 @@ export async function updateWizardCommand(opts = {}) {
 export function registerUpdateCli(program) {
     const update = program
         .command("update")
-        .description("Update Moltbot to the latest version")
+        .description("Update Poolbot to the latest version")
         .option("--json", "Output result as JSON", false)
         .option("--no-restart", "Skip restarting the gateway service after a successful update")
         .option("--channel <stable|beta|dev>", "Persist update channel (git + npm)")

package/dist/cli/webhooks-cli.js

@@ -12,14 +12,14 @@ export function registerWebhooksCli(program) {
     const gmail = webhooks.command("gmail").description("Gmail Pub/Sub hooks (via gogcli)");
     gmail
         .command("setup")
-        .description("Configure Gmail watch + Pub/Sub + Moltbot hooks")
+        .description("Configure Gmail watch + Pub/Sub + Poolbot hooks")
         .requiredOption("--account <email>", "Gmail account to watch")
         .option("--project <id>", "GCP project id (OAuth client owner)")
         .option("--topic <name>", "Pub/Sub topic name", DEFAULT_GMAIL_TOPIC)
         .option("--subscription <name>", "Pub/Sub subscription name", DEFAULT_GMAIL_SUBSCRIPTION)
         .option("--label <label>", "Gmail label to watch", DEFAULT_GMAIL_LABEL)
-        .option("--hook-url <url>", "Moltbot hook URL")
-        .option("--hook-token <token>", "Moltbot hook token")
+        .option("--hook-url <url>", "Poolbot hook URL")
+        .option("--hook-token <token>", "Poolbot hook token")
         .option("--push-token <token>", "Push token for gog watch serve")
         .option("--bind <host>", "gog watch serve bind host", DEFAULT_GMAIL_SERVE_BIND)
         .option("--port <port>", "gog watch serve port", String(DEFAULT_GMAIL_SERVE_PORT))
@@ -49,8 +49,8 @@ export function registerWebhooksCli(program) {
         .option("--topic <topic>", "Pub/Sub topic path (projects/.../topics/..)")
         .option("--subscription <name>", "Pub/Sub subscription name")
         .option("--label <label>", "Gmail label to watch")
-        .option("--hook-url <url>", "Moltbot hook URL")
-        .option("--hook-token <token>", "Moltbot hook token")
+        .option("--hook-url <url>", "Poolbot hook URL")
+        .option("--hook-token <token>", "Poolbot hook token")
         .option("--push-token <token>", "Push token for gog watch serve")
         .option("--bind <host>", "gog watch serve bind host")
         .option("--port <port>", "gog watch serve port")

package/dist/commands/agents.commands.add.js

@@ -129,7 +129,7 @@ export async function agentsAddCommand(opts, runtime = defaultRuntime, params) {
     }
     const prompter = createClackPrompter();
     try {
-        await prompter.intro("Add Moltbot agent");
+        await prompter.intro("Add Poolbot agent");
         const name = nameInput ??
             (await prompter.text({
                 message: "Agent name",

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);