@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/commands/agents.config.js

@@ -1,12 +1,7 @@
-import { resolveAgentDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, } from "../agents/agent-scope.js";
+import { listAgentEntries, resolveAgentDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, } from "../agents/agent-scope.js";
 import { identityHasValues, loadAgentIdentityFromWorkspace, parseIdentityMarkdown as parseIdentityMarkdownFile, } from "../agents/identity-file.js";
 import { normalizeAgentId } from "../routing/session-key.js";
-export function listAgentEntries(cfg) {
-    const list = cfg.agents?.list;
-    if (!Array.isArray(list))
-        return [];
-    return list.filter((entry) => Boolean(entry && typeof entry === "object"));
-}
+export { listAgentEntries };
 export function findAgentEntryIndex(list, agentId) {
     const id = normalizeAgentId(agentId);
     return list.findIndex((entry) => normalizeAgentId(entry.id) === id);
@@ -23,13 +18,15 @@ function resolveAgentModel(cfg, agentId) {
         }
         if (typeof entry.model === "object") {
             const primary = entry.model.primary?.trim();
-            if (primary)
+            if (primary) {
                 return primary;
+            }
         }
     }
     const raw = cfg.agents?.defaults?.model;
-    if (typeof raw === "string")
+    if (typeof raw === "string") {
         return raw;
+    }
     return raw?.primary?.trim() || undefined;
 }
 export function parseIdentityMarkdown(content) {
@@ -37,8 +34,9 @@ export function parseIdentityMarkdown(content) {
 }
 export function loadAgentIdentity(workspace) {
     const parsed = loadAgentIdentityFromWorkspace(workspace);
-    if (!parsed)
+    if (!parsed) {
         return null;
+    }
     return identityHasValues(parsed) ? parsed : null;
 }
 export function buildAgentSummaries(cfg) {

package/dist/commands/agents.providers.js

@@ -63,14 +63,16 @@ export async function buildProviderStatusIndex(cfg) {
 }
 function resolveDefaultAccountId(cfg, provider) {
     const plugin = getChannelPlugin(provider);
-    if (!plugin)
+    if (!plugin) {
         return DEFAULT_ACCOUNT_ID;
+    }
     return resolveChannelDefaultAccountId({ plugin, cfg });
 }
 function shouldShowProviderEntry(entry, cfg) {
     const plugin = getChannelPlugin(entry.provider);
-    if (!plugin)
+    if (!plugin) {
         return Boolean(entry.configured);
+    }
     if (plugin.meta.showConfigured === false) {
         const providerConfig = cfg[plugin.id];
         return Boolean(entry.configured) || Boolean(providerConfig);
@@ -86,13 +88,15 @@ function formatProviderEntry(entry) {
     return `${label}: ${formatProviderState(entry)}`;
 }
 export function summarizeBindings(cfg, bindings) {
-    if (bindings.length === 0)
+    if (bindings.length === 0) {
         return [];
+    }
     const seen = new Map();
     for (const binding of bindings) {
         const channel = normalizeChannelId(binding.match.channel);
-        if (!channel)
+        if (!channel) {
             continue;
+        }
         const accountId = binding.match.accountId ?? resolveDefaultAccountId(cfg, channel);
         const key = providerAccountKey(channel, accountId);
         if (!seen.has(key)) {
@@ -112,12 +116,14 @@ export function listProvidersForAgent(params) {
         const seen = new Set();
         for (const binding of params.bindings) {
             const channel = normalizeChannelId(binding.match.channel);
-            if (!channel)
+            if (!channel) {
                 continue;
+            }
             const accountId = binding.match.accountId ?? resolveDefaultAccountId(params.cfg, channel);
             const key = providerAccountKey(channel, accountId);
-            if (seen.has(key))
+            if (seen.has(key)) {
                 continue;
+            }
             seen.add(key);
             const status = params.providerStatus.get(key);
             if (status) {

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

@@ -1,3 +1,4 @@
+import { AUTH_CHOICE_LEGACY_ALIASES_FOR_CLI } from "./auth-choice-legacy.js";
 const AUTH_CHOICE_GROUP_DEFS = [
     {
         value: "openai",
@@ -11,6 +12,12 @@ const AUTH_CHOICE_GROUP_DEFS = [
         hint: "setup-token + API key",
         choices: ["token", "apiKey"],
     },
+    {
+        value: "chutes",
+        label: "Chutes",
+        hint: "OAuth",
+        choices: ["chutes"],
+    },
     {
         value: "vllm",
         label: "vLLM",
@@ -21,7 +28,7 @@ const AUTH_CHOICE_GROUP_DEFS = [
         value: "minimax",
         label: "MiniMax",
         hint: "M2.5 (recommended)",
-        choices: ["minimax-portal", "minimax-api", "minimax-api-lightning"],
+        choices: ["minimax-portal", "minimax-api", "minimax-api-key-cn", "minimax-api-lightning"],
     },
     {
         value: "moonshot",
@@ -42,10 +49,16 @@ const AUTH_CHOICE_GROUP_DEFS = [
         choices: ["xai-api-key"],
     },
     {
-        value: "nvidia",
-        label: "NVIDIA (Free Tier)",
-        hint: "API key — 23+ frontier models",
-        choices: ["nvidia-api-key"],
+        value: "volcengine",
+        label: "Volcano Engine",
+        hint: "API key",
+        choices: ["volcengine-api-key"],
+    },
+    {
+        value: "byteplus",
+        label: "BytePlus",
+        hint: "API key",
+        choices: ["byteplus-api-key"],
     },
     {
         value: "openrouter",
@@ -138,144 +151,159 @@ const AUTH_CHOICE_GROUP_DEFS = [
         choices: ["custom-api-key"],
     },
 ];
-export function buildAuthChoiceOptions(params) {
-    void params.store;
-    const options = [];
-    options.push({
+const BASE_AUTH_CHOICE_OPTIONS = [
+    {
         value: "token",
         label: "Anthropic token (paste setup-token)",
         hint: "run `claude setup-token` elsewhere, then paste the token here",
-    });
-    options.push({
+    },
+    {
         value: "openai-codex",
         label: "OpenAI Codex (ChatGPT OAuth)",
-    });
-    options.push({ value: "chutes", label: "Chutes (OAuth)" });
-    options.push({
+    },
+    { value: "chutes", label: "Chutes (OAuth)" },
+    {
         value: "vllm",
         label: "vLLM (custom URL + model)",
         hint: "Local/self-hosted OpenAI-compatible server",
-    });
-    options.push({ value: "openai-api-key", label: "OpenAI API key" });
-    options.push({ value: "xai-api-key", label: "xAI (Grok) API key" });
-    options.push({
-        value: "nvidia-api-key",
-        label: "NVIDIA API key",
-        hint: "Free tier — Nemotron, DeepSeek, Kimi, Qwen, and more",
-    });
-    options.push({
+    },
+    { value: "openai-api-key", label: "OpenAI API key" },
+    { value: "xai-api-key", label: "xAI (Grok) API key" },
+    { value: "volcengine-api-key", label: "Volcano Engine API key" },
+    { value: "byteplus-api-key", label: "BytePlus API key" },
+    {
         value: "qianfan-api-key",
         label: "Qianfan API key",
-    });
-    options.push({ value: "openrouter-api-key", label: "OpenRouter API key" });
-    options.push({
+    },
+    { value: "openrouter-api-key", label: "OpenRouter API key" },
+    {
         value: "litellm-api-key",
         label: "LiteLLM API key",
         hint: "Unified gateway for 100+ LLM providers",
-    });
-    options.push({
+    },
+    {
         value: "ai-gateway-api-key",
         label: "Vercel AI Gateway API key",
-    });
-    options.push({
+    },
+    {
         value: "cloudflare-ai-gateway-api-key",
         label: "Cloudflare AI Gateway",
         hint: "Account ID + Gateway ID + API key",
-    });
-    options.push({
+    },
+    {
         value: "moonshot-api-key",
         label: "Kimi API key (.ai)",
-    });
-    options.push({
+    },
+    {
         value: "moonshot-api-key-cn",
         label: "Kimi API key (.cn)",
-    });
-    options.push({
+    },
+    {
         value: "kimi-code-api-key",
         label: "Kimi Code API key (subscription)",
-    });
-    options.push({ value: "synthetic-api-key", label: "Synthetic API key" });
-    options.push({
+    },
+    { value: "synthetic-api-key", label: "Synthetic API key" },
+    {
         value: "venice-api-key",
         label: "Venice AI API key",
         hint: "Privacy-focused inference (uncensored models)",
-    });
-    options.push({
+    },
+    {
         value: "together-api-key",
         label: "Together AI API key",
         hint: "Access to Llama, DeepSeek, Qwen, and more open models",
-    });
-    options.push({
+    },
+    {
         value: "huggingface-api-key",
         label: "Hugging Face API key (HF token)",
         hint: "Inference Providers — OpenAI-compatible chat",
-    });
-    options.push({
+    },
+    {
         value: "github-copilot",
         label: "GitHub Copilot (GitHub device login)",
         hint: "Uses GitHub device flow",
-    });
-    options.push({ value: "gemini-api-key", label: "Google Gemini API key" });
-    options.push({
+    },
+    { value: "gemini-api-key", label: "Google Gemini API key" },
+    {
         value: "google-antigravity",
         label: "Google Antigravity OAuth",
         hint: "Uses the bundled Antigravity auth plugin",
-    });
-    options.push({
+    },
+    {
         value: "google-gemini-cli",
         label: "Google Gemini CLI OAuth",
         hint: "Uses the bundled Gemini CLI auth plugin",
-    });
-    options.push({ value: "zai-api-key", label: "Z.AI API key" });
-    options.push({
+    },
+    { value: "zai-api-key", label: "Z.AI API key" },
+    {
         value: "zai-coding-global",
         label: "Coding-Plan-Global",
         hint: "GLM Coding Plan Global (api.z.ai)",
-    });
-    options.push({
+    },
+    {
         value: "zai-coding-cn",
         label: "Coding-Plan-CN",
         hint: "GLM Coding Plan CN (open.bigmodel.cn)",
-    });
-    options.push({
+    },
+    {
         value: "zai-global",
         label: "Global",
         hint: "Z.AI Global (api.z.ai)",
-    });
-    options.push({
+    },
+    {
         value: "zai-cn",
         label: "CN",
         hint: "Z.AI CN (open.bigmodel.cn)",
-    });
-    options.push({
+    },
+    {
         value: "xiaomi-api-key",
         label: "Xiaomi API key",
-    });
-    options.push({
+    },
+    {
         value: "minimax-portal",
         label: "MiniMax OAuth",
         hint: "Oauth plugin for MiniMax",
-    });
-    options.push({ value: "qwen-portal", label: "Qwen OAuth" });
-    options.push({
+    },
+    { value: "qwen-portal", label: "Qwen OAuth" },
+    {
         value: "copilot-proxy",
         label: "Copilot Proxy (local)",
         hint: "Local proxy for VS Code Copilot models",
-    });
-    options.push({ value: "apiKey", label: "Anthropic API key" });
-    // Token flow is currently Anthropic-only; use CLI for advanced providers.
-    options.push({
+    },
+    { value: "apiKey", label: "Anthropic API key" },
+    {
         value: "opencode-zen",
         label: "OpenCode Zen (multi-model proxy)",
         hint: "Claude, GPT, Gemini via opencode.ai/zen",
-    });
-    options.push({ value: "minimax-api", label: "MiniMax M2.5" });
-    options.push({
+    },
+    { value: "minimax-api", label: "MiniMax M2.5" },
+    {
+        value: "minimax-api-key-cn",
+        label: "MiniMax M2.5 (CN)",
+        hint: "China endpoint (api.minimaxi.com)",
+    },
+    {
         value: "minimax-api-lightning",
         label: "MiniMax M2.5 Lightning",
         hint: "Faster, higher output cost",
-    });
-    options.push({ value: "custom-api-key", label: "Custom Provider" });
+    },
+    { value: "custom-api-key", label: "Custom Provider" },
+];
+export function formatAuthChoiceChoicesForCli(params) {
+    const includeSkip = params?.includeSkip ?? true;
+    const includeLegacyAliases = params?.includeLegacyAliases ?? false;
+    const values = BASE_AUTH_CHOICE_OPTIONS.map((opt) => opt.value);
+    if (includeSkip) {
+        values.push("skip");
+    }
+    if (includeLegacyAliases) {
+        values.push(...AUTH_CHOICE_LEGACY_ALIASES_FOR_CLI);
+    }
+    return values.join("|");
+}
+export function buildAuthChoiceOptions(params) {
+    void params.store;
+    const options = [...BASE_AUTH_CHOICE_OPTIONS];
     if (params.includeSkip) {
         options.push({ value: "skip", label: "Skip for now" });
     }

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

@@ -0,0 +1,55 @@
+import { resolveEnvApiKey } from "../agents/model-auth.js";
+import { upsertSharedEnvVar } from "../infra/env-file.js";
+import { formatApiKeyPreview, normalizeApiKeyInput, validateApiKeyInput, } from "./auth-choice.api-key.js";
+import { applyPrimaryModel } from "./model-picker.js";
+/** Default model for BytePlus auth onboarding. */
+export const BYTEPLUS_DEFAULT_MODEL = "byteplus-plan/ark-code-latest";
+export async function applyAuthChoiceBytePlus(params) {
+    if (params.authChoice !== "byteplus-api-key") {
+        return null;
+    }
+    const envKey = resolveEnvApiKey("byteplus");
+    if (envKey) {
+        const useExisting = await params.prompter.confirm({
+            message: `Use existing BYTEPLUS_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+            initialValue: true,
+        });
+        if (useExisting) {
+            const result = upsertSharedEnvVar({
+                key: "BYTEPLUS_API_KEY",
+                value: envKey.apiKey,
+            });
+            if (!process.env.BYTEPLUS_API_KEY) {
+                process.env.BYTEPLUS_API_KEY = envKey.apiKey;
+            }
+            await params.prompter.note(`Copied BYTEPLUS_API_KEY to ${result.path} for launchd compatibility.`, "BytePlus API key");
+            const configWithModel = applyPrimaryModel(params.config, BYTEPLUS_DEFAULT_MODEL);
+            return {
+                config: configWithModel,
+                agentModelOverride: BYTEPLUS_DEFAULT_MODEL,
+            };
+        }
+    }
+    let key;
+    if (params.opts?.byteplusApiKey) {
+        key = params.opts.byteplusApiKey;
+    }
+    else {
+        key = await params.prompter.text({
+            message: "Enter BytePlus API key",
+            validate: validateApiKeyInput,
+        });
+    }
+    const trimmed = normalizeApiKeyInput(String(key));
+    const result = upsertSharedEnvVar({
+        key: "BYTEPLUS_API_KEY",
+        value: trimmed,
+    });
+    process.env.BYTEPLUS_API_KEY = trimmed;
+    await params.prompter.note(`Saved BYTEPLUS_API_KEY to ${result.path} for launchd compatibility.`, "BytePlus API key");
+    const configWithModel = applyPrimaryModel(params.config, BYTEPLUS_DEFAULT_MODEL);
+    return {
+        config: configWithModel,
+        agentModelOverride: BYTEPLUS_DEFAULT_MODEL,
+    };
+}

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

@@ -9,6 +9,8 @@ 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";
+import { applyAuthChoiceBytePlus } from "./auth-choice.apply.byteplus.js";
+import { applyAuthChoiceVolcengine } from "./auth-choice.apply.volcengine.js";
 export async function applyAuthChoice(params) {
     const handlers = [
         applyAuthChoiceAnthropic,
@@ -22,6 +24,8 @@ export async function applyAuthChoice(params) {
         applyAuthChoiceCopilotProxy,
         applyAuthChoiceQwenPortal,
         applyAuthChoiceXAI,
+        applyAuthChoiceBytePlus,
+        applyAuthChoiceVolcengine,
     ];
     for (const handler of handlers) {
         const result = await handler(params);

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

@@ -1,19 +1,13 @@
 import { resolveEnvApiKey } from "../agents/model-auth.js";
 import { formatApiKeyPreview, normalizeApiKeyInput, validateApiKeyInput, } from "./auth-choice.api-key.js";
+import { createAuthChoiceAgentModelNoter } from "./auth-choice.apply-helpers.js";
+import { applyAuthChoicePluginProvider } from "./auth-choice.apply.plugin-provider.js";
 import { applyDefaultModelChoice } from "./auth-choice.default-model.js";
-import { applyAuthProfileConfig, applyMinimaxApiConfig, applyMinimaxApiProviderConfig, applyMinimaxConfig, applyMinimaxProviderConfig, setMinimaxApiKey, } from "./onboard-auth.js";
+import { applyAuthProfileConfig, applyMinimaxApiConfig, applyMinimaxApiConfigCn, applyMinimaxApiProviderConfig, applyMinimaxApiProviderConfigCn, applyMinimaxConfig, applyMinimaxProviderConfig, setMinimaxApiKey, } from "./onboard-auth.js";
 export async function applyAuthChoiceMiniMax(params) {
     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");
-    };
-    if (params.authChoice === "minimax-cloud" ||
-        params.authChoice === "minimax-api" ||
-        params.authChoice === "minimax-api-lightning") {
-        const modelId = params.authChoice === "minimax-api-lightning" ? "MiniMax-M2.1-lightning" : "MiniMax-M2.1";
+    const ensureMinimaxApiKey = async (opts) => {
         let hasCredential = false;
         const envKey = resolveEnvApiKey("minimax");
         if (envKey) {
@@ -22,17 +16,44 @@ export async function applyAuthChoiceMiniMax(params) {
                 initialValue: true,
             });
             if (useExisting) {
-                await setMinimaxApiKey(envKey.apiKey, params.agentDir);
+                await setMinimaxApiKey(envKey.apiKey, params.agentDir, opts.profileId);
                 hasCredential = true;
             }
         }
         if (!hasCredential) {
             const key = await params.prompter.text({
-                message: "Enter MiniMax API key",
+                message: opts.promptMessage,
                 validate: validateApiKeyInput,
             });
-            await setMinimaxApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+            await setMinimaxApiKey(normalizeApiKeyInput(String(key)), params.agentDir, opts.profileId);
         }
+    };
+    const noteAgentModel = createAuthChoiceAgentModelNoter(params);
+    if (params.authChoice === "minimax-portal") {
+        // Let user choose between Global/CN endpoints
+        const endpoint = await params.prompter.select({
+            message: "Select MiniMax endpoint",
+            options: [
+                { value: "oauth", label: "Global", hint: "OAuth for international users" },
+                { value: "oauth-cn", label: "CN", hint: "OAuth for users in China" },
+            ],
+        });
+        return await applyAuthChoicePluginProvider(params, {
+            authChoice: "minimax-portal",
+            pluginId: "minimax-portal-auth",
+            providerId: "minimax-portal",
+            methodId: endpoint,
+            label: "MiniMax",
+        });
+    }
+    if (params.authChoice === "minimax-cloud" ||
+        params.authChoice === "minimax-api" ||
+        params.authChoice === "minimax-api-lightning") {
+        const modelId = params.authChoice === "minimax-api-lightning" ? "MiniMax-M2.5-Lightning" : "MiniMax-M2.5";
+        await ensureMinimaxApiKey({
+            profileId: "minimax:default",
+            promptMessage: "Enter MiniMax API key",
+        });
         nextConfig = applyAuthProfileConfig(nextConfig, {
             profileId: "minimax:default",
             provider: "minimax",
@@ -54,6 +75,33 @@ export async function applyAuthChoiceMiniMax(params) {
         }
         return { config: nextConfig, agentModelOverride };
     }
+    if (params.authChoice === "minimax-api-key-cn") {
+        const modelId = "MiniMax-M2.5";
+        await ensureMinimaxApiKey({
+            profileId: "minimax-cn:default",
+            promptMessage: "Enter MiniMax China API key",
+        });
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId: "minimax-cn:default",
+            provider: "minimax-cn",
+            mode: "api_key",
+        });
+        {
+            const modelRef = `minimax-cn/${modelId}`;
+            const applied = await applyDefaultModelChoice({
+                config: nextConfig,
+                setDefaultModel: params.setDefaultModel,
+                defaultModel: modelRef,
+                applyDefaultConfig: (config) => applyMinimaxApiConfigCn(config, modelId),
+                applyProviderConfig: (config) => applyMinimaxApiProviderConfigCn(config, modelId),
+                noteAgentModel,
+                prompter: params.prompter,
+            });
+            nextConfig = applied.config;
+            agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+        }
+        return { config: nextConfig, agentModelOverride };
+    }
     if (params.authChoice === "minimax") {
         const applied = await applyDefaultModelChoice({
             config: nextConfig,

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

@@ -87,7 +87,9 @@ export async function applyAuthChoiceOpenAI(params) {
             });
             spin.stop("OpenAI OAuth complete");
             if (creds) {
-                await writeOAuthCredentials("openai-codex", creds, params.agentDir);
+                await writeOAuthCredentials("openai-codex", creds, params.agentDir, {
+                    syncSiblingAgents: true,
+                });
                 nextConfig = applyAuthProfileConfig(nextConfig, {
                     profileId: "openai-codex:default",
                     provider: "openai-codex",

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

@@ -0,0 +1,55 @@
+import { resolveEnvApiKey } from "../agents/model-auth.js";
+import { upsertSharedEnvVar } from "../infra/env-file.js";
+import { formatApiKeyPreview, normalizeApiKeyInput, validateApiKeyInput, } from "./auth-choice.api-key.js";
+import { applyPrimaryModel } from "./model-picker.js";
+/** Default model for Volcano Engine auth onboarding. */
+export const VOLCENGINE_DEFAULT_MODEL = "volcengine-plan/ark-code-latest";
+export async function applyAuthChoiceVolcengine(params) {
+    if (params.authChoice !== "volcengine-api-key") {
+        return null;
+    }
+    const envKey = resolveEnvApiKey("volcengine");
+    if (envKey) {
+        const useExisting = await params.prompter.confirm({
+            message: `Use existing VOLCANO_ENGINE_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+            initialValue: true,
+        });
+        if (useExisting) {
+            const result = upsertSharedEnvVar({
+                key: "VOLCANO_ENGINE_API_KEY",
+                value: envKey.apiKey,
+            });
+            if (!process.env.VOLCANO_ENGINE_API_KEY) {
+                process.env.VOLCANO_ENGINE_API_KEY = envKey.apiKey;
+            }
+            await params.prompter.note(`Copied VOLCANO_ENGINE_API_KEY to ${result.path} for launchd compatibility.`, "Volcano Engine API Key");
+            const configWithModel = applyPrimaryModel(params.config, VOLCENGINE_DEFAULT_MODEL);
+            return {
+                config: configWithModel,
+                agentModelOverride: VOLCENGINE_DEFAULT_MODEL,
+            };
+        }
+    }
+    let key;
+    if (params.opts?.volcengineApiKey) {
+        key = params.opts.volcengineApiKey;
+    }
+    else {
+        key = await params.prompter.text({
+            message: "Enter Volcano Engine API Key",
+            validate: validateApiKeyInput,
+        });
+    }
+    const trimmed = normalizeApiKeyInput(String(key));
+    const result = upsertSharedEnvVar({
+        key: "VOLCANO_ENGINE_API_KEY",
+        value: trimmed,
+    });
+    process.env.VOLCANO_ENGINE_API_KEY = trimmed;
+    await params.prompter.note(`Saved VOLCANO_ENGINE_API_KEY to ${result.path} for launchd compatibility.`, "Volcano Engine API Key");
+    const configWithModel = applyPrimaryModel(params.config, VOLCENGINE_DEFAULT_MODEL);
+    return {
+        config: configWithModel,
+        agentModelOverride: VOLCENGINE_DEFAULT_MODEL,
+    };
+}

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

@@ -41,6 +41,8 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
     "minimax-portal": "minimax-portal",
     "qianfan-api-key": "qianfan",
     "nvidia-api-key": "nvidia",
+    "volcengine-api-key": "volcengine",
+    "byteplus-api-key": "byteplus",
     "custom-api-key": "custom",
 };
 export function resolvePreferredProviderForAuthChoice(choice) {