@poolzin/pool-bot 2026.2.4 → 2026.2.5

package/dist/agents/model-auth.js

@@ -225,6 +225,7 @@ export function resolveEnvApiKey(provider) {
         opencode: "OPENCODE_API_KEY",
         together: "TOGETHER_API_KEY",
         qianfan: "QIANFAN_API_KEY",
+        nvidia: "NVIDIA_API_KEY",
         ollama: "OLLAMA_API_KEY",
     };
     const envVar = envMap[normalized];

package/dist/agents/model-forward-compat.js

@@ -0,0 +1,187 @@
+import { DEFAULT_CONTEXT_TOKENS } from "./defaults.js";
+import { normalizeModelCompat } from "./model-compat.js";
+import { normalizeProviderId } from "./model-selection.js";
+const OPENAI_CODEX_GPT_53_MODEL_ID = "gpt-5.3-codex";
+const OPENAI_CODEX_TEMPLATE_MODEL_IDS = ["gpt-5.2-codex"];
+const ANTHROPIC_OPUS_46_MODEL_ID = "claude-opus-4-6";
+const ANTHROPIC_OPUS_46_DOT_MODEL_ID = "claude-opus-4.6";
+const ANTHROPIC_OPUS_TEMPLATE_MODEL_IDS = ["claude-opus-4-5", "claude-opus-4.5"];
+const ZAI_GLM5_MODEL_ID = "glm-5";
+const ZAI_GLM5_TEMPLATE_MODEL_IDS = ["glm-4.7"];
+const ANTIGRAVITY_OPUS_46_MODEL_ID = "claude-opus-4-6";
+const ANTIGRAVITY_OPUS_46_DOT_MODEL_ID = "claude-opus-4.6";
+const ANTIGRAVITY_OPUS_TEMPLATE_MODEL_IDS = ["claude-opus-4-5", "claude-opus-4.5"];
+const ANTIGRAVITY_OPUS_46_THINKING_MODEL_ID = "claude-opus-4-6-thinking";
+const ANTIGRAVITY_OPUS_46_DOT_THINKING_MODEL_ID = "claude-opus-4.6-thinking";
+const ANTIGRAVITY_OPUS_THINKING_TEMPLATE_MODEL_IDS = [
+    "claude-opus-4-5-thinking",
+    "claude-opus-4.5-thinking",
+];
+export const ANTIGRAVITY_OPUS_46_FORWARD_COMPAT_CANDIDATES = [
+    {
+        id: ANTIGRAVITY_OPUS_46_THINKING_MODEL_ID,
+        templatePrefixes: [
+            "google-antigravity/claude-opus-4-5-thinking",
+            "google-antigravity/claude-opus-4.5-thinking",
+        ],
+    },
+    {
+        id: ANTIGRAVITY_OPUS_46_MODEL_ID,
+        templatePrefixes: ["google-antigravity/claude-opus-4-5", "google-antigravity/claude-opus-4.5"],
+    },
+];
+function resolveOpenAICodexGpt53FallbackModel(provider, modelId, modelRegistry) {
+    const normalizedProvider = normalizeProviderId(provider);
+    const trimmedModelId = modelId.trim();
+    if (normalizedProvider !== "openai-codex") {
+        return undefined;
+    }
+    if (trimmedModelId.toLowerCase() !== OPENAI_CODEX_GPT_53_MODEL_ID) {
+        return undefined;
+    }
+    for (const templateId of OPENAI_CODEX_TEMPLATE_MODEL_IDS) {
+        const template = modelRegistry.find(normalizedProvider, templateId);
+        if (!template) {
+            continue;
+        }
+        return normalizeModelCompat({
+            ...template,
+            id: trimmedModelId,
+            name: trimmedModelId,
+        });
+    }
+    return normalizeModelCompat({
+        id: trimmedModelId,
+        name: trimmedModelId,
+        api: "openai-codex-responses",
+        provider: normalizedProvider,
+        baseUrl: "https://chatgpt.com/backend-api",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: DEFAULT_CONTEXT_TOKENS,
+        maxTokens: DEFAULT_CONTEXT_TOKENS,
+    });
+}
+function resolveAnthropicOpus46ForwardCompatModel(provider, modelId, modelRegistry) {
+    const normalizedProvider = normalizeProviderId(provider);
+    if (normalizedProvider !== "anthropic") {
+        return undefined;
+    }
+    const trimmedModelId = modelId.trim();
+    const lower = trimmedModelId.toLowerCase();
+    const isOpus46 = lower === ANTHROPIC_OPUS_46_MODEL_ID ||
+        lower === ANTHROPIC_OPUS_46_DOT_MODEL_ID ||
+        lower.startsWith(`${ANTHROPIC_OPUS_46_MODEL_ID}-`) ||
+        lower.startsWith(`${ANTHROPIC_OPUS_46_DOT_MODEL_ID}-`);
+    if (!isOpus46) {
+        return undefined;
+    }
+    const templateIds = [];
+    if (lower.startsWith(ANTHROPIC_OPUS_46_MODEL_ID)) {
+        templateIds.push(lower.replace(ANTHROPIC_OPUS_46_MODEL_ID, "claude-opus-4-5"));
+    }
+    if (lower.startsWith(ANTHROPIC_OPUS_46_DOT_MODEL_ID)) {
+        templateIds.push(lower.replace(ANTHROPIC_OPUS_46_DOT_MODEL_ID, "claude-opus-4.5"));
+    }
+    templateIds.push(...ANTHROPIC_OPUS_TEMPLATE_MODEL_IDS);
+    for (const templateId of [...new Set(templateIds)].filter(Boolean)) {
+        const template = modelRegistry.find(normalizedProvider, templateId);
+        if (!template) {
+            continue;
+        }
+        return normalizeModelCompat({
+            ...template,
+            id: trimmedModelId,
+            name: trimmedModelId,
+        });
+    }
+    return undefined;
+}
+// Z.ai's GLM-5 may not be present in pi-ai's built-in model catalog yet.
+// When a user configures zai/glm-5 without a models.json entry, clone glm-4.7 as a forward-compat fallback.
+function resolveZaiGlm5ForwardCompatModel(provider, modelId, modelRegistry) {
+    if (normalizeProviderId(provider) !== "zai") {
+        return undefined;
+    }
+    const trimmed = modelId.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower !== ZAI_GLM5_MODEL_ID && !lower.startsWith(`${ZAI_GLM5_MODEL_ID}-`)) {
+        return undefined;
+    }
+    for (const templateId of ZAI_GLM5_TEMPLATE_MODEL_IDS) {
+        const template = modelRegistry.find("zai", templateId);
+        if (!template) {
+            continue;
+        }
+        return normalizeModelCompat({
+            ...template,
+            id: trimmed,
+            name: trimmed,
+            reasoning: true,
+        });
+    }
+    return normalizeModelCompat({
+        id: trimmed,
+        name: trimmed,
+        api: "openai-completions",
+        provider: "zai",
+        reasoning: true,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: DEFAULT_CONTEXT_TOKENS,
+        maxTokens: DEFAULT_CONTEXT_TOKENS,
+    });
+}
+function resolveAntigravityOpus46ForwardCompatModel(provider, modelId, modelRegistry) {
+    const normalizedProvider = normalizeProviderId(provider);
+    if (normalizedProvider !== "google-antigravity") {
+        return undefined;
+    }
+    const trimmedModelId = modelId.trim();
+    const lower = trimmedModelId.toLowerCase();
+    const isOpus46 = lower === ANTIGRAVITY_OPUS_46_MODEL_ID ||
+        lower === ANTIGRAVITY_OPUS_46_DOT_MODEL_ID ||
+        lower.startsWith(`${ANTIGRAVITY_OPUS_46_MODEL_ID}-`) ||
+        lower.startsWith(`${ANTIGRAVITY_OPUS_46_DOT_MODEL_ID}-`);
+    const isOpus46Thinking = lower === ANTIGRAVITY_OPUS_46_THINKING_MODEL_ID ||
+        lower === ANTIGRAVITY_OPUS_46_DOT_THINKING_MODEL_ID ||
+        lower.startsWith(`${ANTIGRAVITY_OPUS_46_THINKING_MODEL_ID}-`) ||
+        lower.startsWith(`${ANTIGRAVITY_OPUS_46_DOT_THINKING_MODEL_ID}-`);
+    if (!isOpus46 && !isOpus46Thinking) {
+        return undefined;
+    }
+    const templateIds = [];
+    if (lower.startsWith(ANTIGRAVITY_OPUS_46_MODEL_ID)) {
+        templateIds.push(lower.replace(ANTIGRAVITY_OPUS_46_MODEL_ID, "claude-opus-4-5"));
+    }
+    if (lower.startsWith(ANTIGRAVITY_OPUS_46_DOT_MODEL_ID)) {
+        templateIds.push(lower.replace(ANTIGRAVITY_OPUS_46_DOT_MODEL_ID, "claude-opus-4.5"));
+    }
+    if (lower.startsWith(ANTIGRAVITY_OPUS_46_THINKING_MODEL_ID)) {
+        templateIds.push(lower.replace(ANTIGRAVITY_OPUS_46_THINKING_MODEL_ID, "claude-opus-4-5-thinking"));
+    }
+    if (lower.startsWith(ANTIGRAVITY_OPUS_46_DOT_THINKING_MODEL_ID)) {
+        templateIds.push(lower.replace(ANTIGRAVITY_OPUS_46_DOT_THINKING_MODEL_ID, "claude-opus-4.5-thinking"));
+    }
+    templateIds.push(...ANTIGRAVITY_OPUS_TEMPLATE_MODEL_IDS);
+    templateIds.push(...ANTIGRAVITY_OPUS_THINKING_TEMPLATE_MODEL_IDS);
+    for (const templateId of [...new Set(templateIds)].filter(Boolean)) {
+        const template = modelRegistry.find(normalizedProvider, templateId);
+        if (!template) {
+            continue;
+        }
+        return normalizeModelCompat({
+            ...template,
+            id: trimmedModelId,
+            name: trimmedModelId,
+        });
+    }
+    return undefined;
+}
+export function resolveForwardCompatModel(provider, modelId, modelRegistry) {
+    return (resolveOpenAICodexGpt53FallbackModel(provider, modelId, modelRegistry) ??
+        resolveAnthropicOpus46ForwardCompatModel(provider, modelId, modelRegistry) ??
+        resolveZaiGlm5ForwardCompatModel(provider, modelId, modelRegistry) ??
+        resolveAntigravityOpus46ForwardCompatModel(provider, modelId, modelRegistry));
+}

package/dist/agents/pi-embedded-runner/model.js

@@ -1,8 +1,9 @@
-import { discoverAuthStorage, discoverModels } from "../pi-model-discovery.js";
 import { resolvePoolbotAgentDir } from "../agent-paths.js";
 import { DEFAULT_CONTEXT_TOKENS } from "../defaults.js";
 import { normalizeModelCompat } from "../model-compat.js";
+import { resolveForwardCompatModel } from "../model-forward-compat.js";
 import { normalizeProviderId } from "../model-selection.js";
+import { discoverAuthStorage, discoverModels, } from "../pi-model-discovery.js";
 export function buildInlineProviderModels(providers) {
     return Object.entries(providers).flatMap(([providerId, entry]) => {
         const trimmed = providerId.trim();
@@ -12,7 +13,7 @@ export function buildInlineProviderModels(providers) {
             ...model,
             provider: trimmed,
             baseUrl: entry?.baseUrl,
-            ...(entry?.api && !model.api ? { api: entry.api } : {}),
+            api: model.api ?? entry?.api,
         }));
     });
 }
@@ -32,65 +33,12 @@ export function buildModelAliasLines(cfg) {
         .toSorted((a, b) => a.alias.localeCompare(b.alias))
         .map((entry) => `- ${entry.alias}: ${entry.model}`);
 }
-// Well-known model IDs for forward-compatible resolution
-export const OPENAI_CODEX_GPT_53_MODEL_ID = "codex-gpt-5.3";
-export const OPENAI_CODEX_TEMPLATE_MODEL_IDS = ["codex-mini-*"];
-export const ANTHROPIC_OPUS_46_MODEL_ID = "claude-opus-4-0624";
-export const ANTHROPIC_OPUS_46_DOT_MODEL_ID = "claude-opus-4.6";
-export const ANTHROPIC_OPUS_TEMPLATE_MODEL_IDS = ["claude-opus-4-*", "claude-opus-4.*"];
-/**
- * Resolve forward-compat fallback for OpenAI codex-gpt-5.3 requests.
- * If the exact model is not in the registry, try `codex-mini-*` template matches.
- */
-export function resolveOpenAICodexGpt53FallbackModel(modelRegistry, provider) {
-    for (const templateId of OPENAI_CODEX_TEMPLATE_MODEL_IDS) {
-        const match = modelRegistry.find(provider, templateId);
-        if (match)
-            return match;
-    }
-    return null;
-}
-/**
- * Resolve forward-compat fallback for Anthropic claude-opus-4.6 requests.
- * If the exact model is not in the registry, try `claude-opus-4-*` template matches.
- */
-export function resolveAnthropicOpus46ForwardCompatModel(modelRegistry, provider, modelId) {
-    if (modelId !== ANTHROPIC_OPUS_46_MODEL_ID && modelId !== ANTHROPIC_OPUS_46_DOT_MODEL_ID) {
-        return null;
-    }
-    for (const templateId of ANTHROPIC_OPUS_TEMPLATE_MODEL_IDS) {
-        const match = modelRegistry.find(provider, templateId);
-        if (match)
-            return match;
-    }
-    return null;
-}
 export function resolveModel(provider, modelId, agentDir, cfg) {
     const resolvedAgentDir = agentDir ?? resolvePoolbotAgentDir();
     const authStorage = discoverAuthStorage(resolvedAgentDir);
     const modelRegistry = discoverModels(authStorage, resolvedAgentDir);
     const model = modelRegistry.find(provider, modelId);
     if (!model) {
-        // Try codex forward-compat fallback
-        if (modelId === OPENAI_CODEX_GPT_53_MODEL_ID) {
-            const codexFallback = resolveOpenAICodexGpt53FallbackModel(modelRegistry, provider);
-            if (codexFallback) {
-                return {
-                    model: normalizeModelCompat(codexFallback),
-                    authStorage,
-                    modelRegistry,
-                };
-            }
-        }
-        // Try Anthropic opus forward-compat fallback
-        const opusFallback = resolveAnthropicOpus46ForwardCompatModel(modelRegistry, provider, modelId);
-        if (opusFallback) {
-            return {
-                model: normalizeModelCompat(opusFallback),
-                authStorage,
-                modelRegistry,
-            };
-        }
         const providers = cfg?.models?.providers ?? {};
         const inlineModels = buildInlineProviderModels(providers);
         const normalizedProvider = normalizeProviderId(provider);
@@ -103,6 +51,12 @@ export function resolveModel(provider, modelId, agentDir, cfg) {
                 modelRegistry,
             };
         }
+        // Forward-compat fallbacks must be checked BEFORE the generic providerCfg fallback.
+        // Otherwise, configured providers can default to a generic API and break specific transports.
+        const forwardCompat = resolveForwardCompatModel(provider, modelId, modelRegistry);
+        if (forwardCompat) {
+            return { model: forwardCompat, authStorage, modelRegistry };
+        }
         const providerCfg = providers[provider];
         if (providerCfg || modelId.startsWith("mock-")) {
             const fallbackModel = normalizeModelCompat({
@@ -110,12 +64,12 @@ export function resolveModel(provider, modelId, agentDir, cfg) {
                 name: modelId,
                 api: providerCfg?.api ?? "openai-responses",
                 provider,
+                baseUrl: providerCfg?.baseUrl,
                 reasoning: false,
                 input: ["text"],
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
                 contextWindow: providerCfg?.models?.[0]?.contextWindow ?? DEFAULT_CONTEXT_TOKENS,
                 maxTokens: providerCfg?.models?.[0]?.maxTokens ?? DEFAULT_CONTEXT_TOKENS,
-                baseUrl: providerCfg?.baseUrl,
             });
             return { model: fallbackModel, authStorage, modelRegistry };
         }

package/dist/browser/constants.js

@@ -1,6 +1,6 @@
 export const DEFAULT_CLAWD_BROWSER_ENABLED = true;
 export const DEFAULT_BROWSER_EVALUATE_ENABLED = true;
-export const DEFAULT_CLAWD_BROWSER_COLOR = "#FF4500";
+export const DEFAULT_CLAWD_BROWSER_COLOR = "#A855F7";
 export const DEFAULT_CLAWD_BROWSER_PROFILE_NAME = "clawd";
 export const DEFAULT_BROWSER_DEFAULT_PROFILE_NAME = "chrome";
 export const DEFAULT_AI_SNAPSHOT_MAX_CHARS = 80_000;

package/dist/browser/profiles.js

@@ -63,7 +63,7 @@ export function getUsedPorts(profiles) {
     return used;
 }
 export const PROFILE_COLORS = [
-    "#FF4500", // Orange-red (clawd default)
+    "#A855F7", // Purple (poolbot default)
     "#0066CC", // Blue
     "#00AA00", // Green
     "#9933FF", // Purple

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.2.4",
-  "commit": "c64f0b4b98cd3ef3ffe676270cab95c2c859479d",
-  "builtAt": "2026-02-14T01:53:48.010Z"
+  "version": "2026.2.5",
+  "commit": "b05c49be3d3a8a8bba6ab957a7ef10c3c4856f8d",
+  "builtAt": "2026-02-14T04:39:03.692Z"
 }

package/dist/cli/program/register.onboard.js

@@ -46,6 +46,11 @@ export function registerOnboardCommand(program) {
         .option("--synthetic-api-key <key>", "Synthetic API key")
         .option("--venice-api-key <key>", "Venice API key")
         .option("--opencode-zen-api-key <key>", "OpenCode Zen API key")
+        .option("--xai-api-key <key>", "xAI API key")
+        .option("--together-api-key <key>", "Together AI API key")
+        .option("--qianfan-api-key <key>", "Qianfan API key")
+        .option("--xiaomi-api-key <key>", "Xiaomi API key")
+        .option("--nvidia-api-key <key>", "NVIDIA API key")
         .option("--gateway-port <port>", "Gateway port")
         .option("--gateway-bind <mode>", "Gateway bind: loopback|tailnet|lan|auto|custom")
         .option("--gateway-auth <mode>", "Gateway auth: token|password")
@@ -94,6 +99,11 @@ export function registerOnboardCommand(program) {
                 syntheticApiKey: opts.syntheticApiKey,
                 veniceApiKey: opts.veniceApiKey,
                 opencodeZenApiKey: opts.opencodeZenApiKey,
+                xaiApiKey: opts.xaiApiKey,
+                togetherApiKey: opts.togetherApiKey,
+                qianfanApiKey: opts.qianfanApiKey,
+                xiaomiApiKey: opts.xiaomiApiKey,
+                nvidiaApiKey: opts.nvidiaApiKey,
                 gatewayPort: typeof gatewayPort === "number" && Number.isFinite(gatewayPort)
                     ? gatewayPort
                     : undefined,

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

@@ -35,6 +35,12 @@ const AUTH_CHOICE_GROUP_DEFS = [
         hint: "API key",
         choices: ["xai-api-key"],
     },
+    {
+        value: "nvidia",
+        label: "NVIDIA (Free Tier)",
+        hint: "API key — 23+ frontier models",
+        choices: ["nvidia-api-key"],
+    },
     {
         value: "openrouter",
         label: "OpenRouter",
@@ -129,6 +135,11 @@ export function buildAuthChoiceOptions(params) {
     options.push({ value: "chutes", label: "Chutes (OAuth)" });
     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: "qianfan-api-key",
         label: "Qianfan API key",

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

@@ -3,7 +3,7 @@ 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, 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 { 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, applyNvidiaConfig, applyNvidiaProviderConfig, CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, NVIDIA_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, setNvidiaApiKey, 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;
@@ -59,6 +59,9 @@ export async function applyAuthChoiceApiProviders(params) {
         else if (params.opts.tokenProvider === "qianfan") {
             authChoice = "qianfan-api-key";
         }
+        else if (params.opts.tokenProvider === "nvidia") {
+            authChoice = "nvidia-api-key";
+        }
     }
     if (authChoice === "openrouter-api-key") {
         const store = ensureAuthProfileStore(params.agentDir, {
@@ -786,5 +789,56 @@ export async function applyAuthChoiceApiProviders(params) {
         }
         return { config: nextConfig, agentModelOverride };
     }
+    if (authChoice === "nvidia-api-key") {
+        let hasCredential = false;
+        if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "nvidia") {
+            setNvidiaApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+            hasCredential = true;
+        }
+        if (!hasCredential) {
+            await params.prompter.note([
+                "Get your API key at: https://build.nvidia.com/settings/api-key",
+                "Free tier includes 1,000 requests/day across 23+ frontier models.",
+            ].join("\n"), "NVIDIA");
+        }
+        const envKey = resolveEnvApiKey("nvidia");
+        if (envKey) {
+            const useExisting = await params.prompter.confirm({
+                message: `Use existing NVIDIA_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                initialValue: true,
+            });
+            if (useExisting) {
+                setNvidiaApiKey(envKey.apiKey, params.agentDir);
+                hasCredential = true;
+            }
+        }
+        if (!hasCredential) {
+            const key = await params.prompter.text({
+                message: "Enter NVIDIA API key",
+                validate: validateApiKeyInput,
+            });
+            setNvidiaApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
+        }
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId: "nvidia:default",
+            provider: "nvidia",
+            mode: "api_key",
+        });
+        {
+            const applied = await applyDefaultModelChoice({
+                config: nextConfig,
+                setDefaultModel: params.setDefaultModel,
+                defaultModel: NVIDIA_DEFAULT_MODEL_REF,
+                applyDefaultConfig: applyNvidiaConfig,
+                applyProviderConfig: applyNvidiaProviderConfig,
+                noteDefault: NVIDIA_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.plugin-provider.js

@@ -1,7 +1,6 @@
 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";
 import { resolveDefaultAgentWorkspaceDir } from "../agents/workspace.js";
 import { enablePluginInConfig } from "../plugins/enable.js";
 import { resolvePluginProviders } from "../plugins/providers.js";
@@ -9,61 +8,7 @@ import { applyAuthProfileConfig } from "./onboard-auth.js";
 import { openUrl } from "./onboard-helpers.js";
 import { createVpsAwareOAuthHandlers } from "./oauth-flow.js";
 import { isRemoteEnvironment } from "./oauth-env.js";
-function resolveProviderMatch(providers, rawProvider) {
-    const normalized = normalizeProviderId(rawProvider);
-    return (providers.find((provider) => normalizeProviderId(provider.id) === normalized) ??
-        providers.find((provider) => provider.aliases?.some((alias) => normalizeProviderId(alias) === normalized) ?? false) ??
-        null);
-}
-function pickAuthMethod(provider, rawMethod) {
-    const raw = rawMethod?.trim();
-    if (!raw)
-        return null;
-    const normalized = raw.toLowerCase();
-    return (provider.auth.find((method) => method.id.toLowerCase() === normalized) ??
-        provider.auth.find((method) => method.label.toLowerCase() === normalized) ??
-        null);
-}
-function isPlainRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function mergeConfigPatch(base, patch) {
-    if (!isPlainRecord(base) || !isPlainRecord(patch)) {
-        return patch;
-    }
-    const next = { ...base };
-    for (const [key, value] of Object.entries(patch)) {
-        const existing = next[key];
-        if (isPlainRecord(existing) && isPlainRecord(value)) {
-            next[key] = mergeConfigPatch(existing, value);
-        }
-        else {
-            next[key] = value;
-        }
-    }
-    return next;
-}
-function applyDefaultModel(cfg, model) {
-    const models = { ...cfg.agents?.defaults?.models };
-    models[model] = models[model] ?? {};
-    const existingModel = cfg.agents?.defaults?.model;
-    return {
-        ...cfg,
-        agents: {
-            ...cfg.agents,
-            defaults: {
-                ...cfg.agents?.defaults,
-                models,
-                model: {
-                    ...(existingModel && typeof existingModel === "object" && "fallbacks" in existingModel
-                        ? { fallbacks: existingModel.fallbacks }
-                        : undefined),
-                    primary: model,
-                },
-            },
-        },
-    };
-}
+import { applyDefaultModel, mergeConfigPatch, pickAuthMethod, resolveProviderMatch, } from "./provider-auth-helpers.js";
 export async function applyAuthChoicePluginProvider(params, options) {
     if (params.authChoice !== options.authChoice)
         return null;

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

@@ -32,6 +32,7 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
     "xai-api-key": "xai",
     "qwen-portal": "qwen-portal",
     "qianfan-api-key": "qianfan",
+    "nvidia-api-key": "nvidia",
 };
 export function resolvePreferredProviderForAuthChoice(choice) {
     return PREFERRED_PROVIDER_BY_AUTH_CHOICE[choice];

package/dist/commands/models/auth.js

@@ -12,6 +12,7 @@ import { applyAuthProfileConfig } from "../onboard-auth.js";
 import { isRemoteEnvironment } from "../oauth-env.js";
 import { openUrl } from "../onboard-helpers.js";
 import { createVpsAwareOAuthHandlers } from "../oauth-flow.js";
+import { applyDefaultModel, mergeConfigPatch, pickAuthMethod, resolveProviderMatch, } from "../provider-auth-helpers.js";
 import { updateConfig } from "./shared.js";
 import { resolvePluginProviders } from "../../plugins/providers.js";
 import { createClackPrompter } from "../../wizard/clack-prompter.js";
@@ -167,64 +168,6 @@ export async function modelsAuthAddCommand(_opts, runtime) {
         : undefined;
     await modelsAuthPasteTokenCommand({ provider: providerId, profileId, expiresIn }, runtime);
 }
-function resolveProviderMatch(providers, rawProvider) {
-    const raw = rawProvider?.trim();
-    if (!raw)
-        return null;
-    const normalized = normalizeProviderId(raw);
-    return (providers.find((provider) => normalizeProviderId(provider.id) === normalized) ??
-        providers.find((provider) => provider.aliases?.some((alias) => normalizeProviderId(alias) === normalized) ?? false) ??
-        null);
-}
-function pickAuthMethod(provider, rawMethod) {
-    const raw = rawMethod?.trim();
-    if (!raw)
-        return null;
-    const normalized = raw.toLowerCase();
-    return (provider.auth.find((method) => method.id.toLowerCase() === normalized) ??
-        provider.auth.find((method) => method.label.toLowerCase() === normalized) ??
-        null);
-}
-function isPlainRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function mergeConfigPatch(base, patch) {
-    if (!isPlainRecord(base) || !isPlainRecord(patch)) {
-        return patch;
-    }
-    const next = { ...base };
-    for (const [key, value] of Object.entries(patch)) {
-        const existing = next[key];
-        if (isPlainRecord(existing) && isPlainRecord(value)) {
-            next[key] = mergeConfigPatch(existing, value);
-        }
-        else {
-            next[key] = value;
-        }
-    }
-    return next;
-}
-function applyDefaultModel(cfg, model) {
-    const models = { ...cfg.agents?.defaults?.models };
-    models[model] = models[model] ?? {};
-    const existingModel = cfg.agents?.defaults?.model;
-    return {
-        ...cfg,
-        agents: {
-            ...cfg.agents,
-            defaults: {
-                ...cfg.agents?.defaults,
-                models,
-                model: {
-                    ...(existingModel && typeof existingModel === "object" && "fallbacks" in existingModel
-                        ? { fallbacks: existingModel.fallbacks }
-                        : undefined),
-                    primary: model,
-                },
-            },
-        },
-    };
-}
 function credentialMode(credential) {
     if (credential.type === "api_key")
         return "api_key";

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

@@ -0,0 +1,14 @@
+export const MODEL_AVAILABILITY_UNAVAILABLE_CODE = "MODEL_AVAILABILITY_UNAVAILABLE";
+export function formatErrorWithStack(err) {
+    if (err instanceof Error) {
+        return err.stack ?? `${err.name}: ${err.message}`;
+    }
+    return String(err);
+}
+export function shouldFallbackToAuthHeuristics(err) {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    const code = err.code;
+    return code === MODEL_AVAILABILITY_UNAVAILABLE_CODE;
+}

package/dist/commands/models/list.list-command.js

@@ -1,10 +1,13 @@
 import { ensureAuthProfileStore } from "../../agents/auth-profiles.js";
+import { resolveForwardCompatModel } from "../../agents/model-forward-compat.js";
 import { parseModelRef } from "../../agents/model-selection.js";
+import { resolveModel } from "../../agents/pi-embedded-runner/model.js";
 import { loadConfig } from "../../config/config.js";
 import { resolveConfiguredEntries } from "./list.configured.js";
+import { formatErrorWithStack } from "./list.errors.js";
 import { loadModelRegistry, toModelRow } from "./list.registry.js";
 import { printModelTable } from "./list.table.js";
-import { DEFAULT_PROVIDER, ensureFlagCompatibility, modelKey } from "./shared.js";
+import { DEFAULT_PROVIDER, ensureFlagCompatibility, isLocalBaseUrl, modelKey } from "./shared.js";
 export async function modelsListCommand(opts, runtime) {
     ensureFlagCompatibility(opts);
     const cfg = loadConfig();
@@ -17,35 +20,30 @@ export async function modelsListCommand(opts, runtime) {
         return parsed?.provider ?? raw.toLowerCase();
     })();
     let models = [];
+    let modelRegistry;
     let availableKeys;
+    let availabilityErrorMessage;
     try {
         const loaded = await loadModelRegistry(cfg);
+        modelRegistry = loaded.registry;
         models = loaded.models;
         availableKeys = loaded.availableKeys;
+        availabilityErrorMessage = loaded.availabilityErrorMessage;
     }
     catch (err) {
-        runtime.error(`Model registry unavailable: ${String(err)}`);
+        runtime.error(`Model registry unavailable:\n${formatErrorWithStack(err)}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (availabilityErrorMessage !== undefined) {
+        runtime.error(`Model availability lookup failed; falling back to auth heuristics for discovered models: ${availabilityErrorMessage}`);
     }
     const modelByKey = new Map(models.map((model) => [modelKey(model.provider, model.id), model]));
     const { entries } = resolveConfiguredEntries(cfg);
     const configuredByKey = new Map(entries.map((entry) => [entry.key, entry]));
     const rows = [];
-    const isLocalBaseUrl = (baseUrl) => {
-        try {
-            const url = new URL(baseUrl);
-            const host = url.hostname.toLowerCase();
-            return (host === "localhost" ||
-                host === "127.0.0.1" ||
-                host === "0.0.0.0" ||
-                host === "::1" ||
-                host.endsWith(".local"));
-        }
-        catch {
-            return false;
-        }
-    };
     if (opts.all) {
-        const sorted = [...models].sort((a, b) => {
+        const sorted = [...models].toSorted((a, b) => {
             const p = a.provider.localeCompare(b.provider);
             if (p !== 0)
                 return p;
@@ -55,8 +53,9 @@ export async function modelsListCommand(opts, runtime) {
             if (providerFilter && model.provider.toLowerCase() !== providerFilter) {
                 continue;
             }
-            if (opts.local && !isLocalBaseUrl(model.baseUrl))
+            if (opts.local && !isLocalBaseUrl(model.baseUrl)) {
                 continue;
+            }
             const key = modelKey(model.provider, model.id);
             const configured = configuredByKey.get(key);
             rows.push(toModelRow({
@@ -75,11 +74,23 @@ export async function modelsListCommand(opts, runtime) {
             if (providerFilter && entry.ref.provider.toLowerCase() !== providerFilter) {
                 continue;
             }
-            const model = modelByKey.get(entry.key);
-            if (opts.local && model && !isLocalBaseUrl(model.baseUrl))
+            let model = modelByKey.get(entry.key);
+            if (!model && modelRegistry) {
+                const forwardCompat = resolveForwardCompatModel(entry.ref.provider, entry.ref.model, modelRegistry);
+                if (forwardCompat) {
+                    model = forwardCompat;
+                    modelByKey.set(entry.key, forwardCompat);
+                }
+            }
+            if (!model) {
+                model = resolveModel(entry.ref.provider, entry.ref.model, undefined, cfg).model;
+            }
+            if (opts.local && model && !isLocalBaseUrl(model.baseUrl)) {
                 continue;
-            if (opts.local && !model)
+            }
+            if (opts.local && !model) {
                 continue;
+            }
             rows.push(toModelRow({
                 model,
                 key: entry.key,

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

@@ -1,43 +1,129 @@
-import { discoverAuthStorage, discoverModels } from "../../agents/pi-model-discovery.js";
 import { resolvePoolbotAgentDir } from "../../agents/agent-paths.js";
 import { listProfilesForProvider } from "../../agents/auth-profiles.js";
 import { getCustomProviderApiKey, resolveAwsSdkEnvVarName, resolveEnvApiKey, } from "../../agents/model-auth.js";
+import { ANTIGRAVITY_OPUS_46_FORWARD_COMPAT_CANDIDATES, resolveForwardCompatModel, } from "../../agents/model-forward-compat.js";
 import { ensurePoolbotModelsJson } from "../../agents/models-config.js";
-import { modelKey } from "./shared.js";
-const isLocalBaseUrl = (baseUrl) => {
-    try {
-        const url = new URL(baseUrl);
-        const host = url.hostname.toLowerCase();
-        return (host === "localhost" ||
-            host === "127.0.0.1" ||
-            host === "0.0.0.0" ||
-            host === "::1" ||
-            host.endsWith(".local"));
-    }
-    catch {
+import { discoverAuthStorage, discoverModels } from "../../agents/pi-model-discovery.js";
+import { formatErrorWithStack, MODEL_AVAILABILITY_UNAVAILABLE_CODE, shouldFallbackToAuthHeuristics, } from "./list.errors.js";
+import { isLocalBaseUrl, modelKey } from "./shared.js";
+const hasAuthForProvider = (provider, cfg, authStore) => {
+    if (!cfg || !authStore) {
         return false;
     }
-};
-const hasAuthForProvider = (provider, cfg, authStore) => {
-    if (listProfilesForProvider(authStore, provider).length > 0)
+    if (listProfilesForProvider(authStore, provider).length > 0) {
         return true;
-    if (provider === "amazon-bedrock" && resolveAwsSdkEnvVarName())
+    }
+    if (provider === "amazon-bedrock" && resolveAwsSdkEnvVarName()) {
         return true;
-    if (resolveEnvApiKey(provider))
+    }
+    if (resolveEnvApiKey(provider)) {
         return true;
-    if (getCustomProviderApiKey(cfg, provider))
+    }
+    if (getCustomProviderApiKey(cfg, provider)) {
         return true;
+    }
     return false;
 };
+function createAvailabilityUnavailableError(message) {
+    const err = new Error(message);
+    err.code = MODEL_AVAILABILITY_UNAVAILABLE_CODE;
+    return err;
+}
+function normalizeAvailabilityError(err) {
+    if (shouldFallbackToAuthHeuristics(err) && err instanceof Error) {
+        return err;
+    }
+    return createAvailabilityUnavailableError(`Model availability unavailable: getAvailable() failed.\n${formatErrorWithStack(err)}`);
+}
+function validateAvailableModels(availableModels) {
+    if (!Array.isArray(availableModels)) {
+        throw createAvailabilityUnavailableError("Model availability unavailable: getAvailable() returned a non-array value.");
+    }
+    for (const model of availableModels) {
+        if (!model ||
+            typeof model !== "object" ||
+            typeof model.provider !== "string" ||
+            typeof model.id !== "string") {
+            throw createAvailabilityUnavailableError("Model availability unavailable: getAvailable() returned invalid model entries.");
+        }
+    }
+    return availableModels;
+}
+function loadAvailableModels(registry) {
+    let availableModels;
+    try {
+        availableModels = registry.getAvailable();
+    }
+    catch (err) {
+        throw normalizeAvailabilityError(err);
+    }
+    try {
+        return validateAvailableModels(availableModels);
+    }
+    catch (err) {
+        throw normalizeAvailabilityError(err);
+    }
+}
 export async function loadModelRegistry(cfg) {
     await ensurePoolbotModelsJson(cfg);
     const agentDir = resolvePoolbotAgentDir();
     const authStorage = discoverAuthStorage(agentDir);
     const registry = discoverModels(authStorage, agentDir);
-    const models = registry.getAll();
-    const availableModels = registry.getAvailable();
-    const availableKeys = new Set(availableModels.map((model) => modelKey(model.provider, model.id)));
-    return { registry, models, availableKeys };
+    const appended = appendAntigravityForwardCompatModels(registry.getAll(), registry);
+    const models = appended.models;
+    const synthesizedForwardCompat = appended.synthesizedForwardCompat;
+    let availableKeys;
+    let availabilityErrorMessage;
+    try {
+        const availableModels = loadAvailableModels(registry);
+        availableKeys = new Set(availableModels.map((model) => modelKey(model.provider, model.id)));
+        for (const synthesized of synthesizedForwardCompat) {
+            if (hasAvailableTemplate(availableKeys, synthesized.templatePrefixes)) {
+                availableKeys.add(synthesized.key);
+            }
+        }
+    }
+    catch (err) {
+        if (!shouldFallbackToAuthHeuristics(err)) {
+            throw err;
+        }
+        // Some providers can report model-level availability as unavailable.
+        // Fall back to provider-level auth heuristics when availability is undefined.
+        availableKeys = undefined;
+        if (!availabilityErrorMessage) {
+            availabilityErrorMessage = formatErrorWithStack(err);
+        }
+    }
+    return { registry, models, availableKeys, availabilityErrorMessage };
+}
+function appendAntigravityForwardCompatModels(models, modelRegistry) {
+    const nextModels = [...models];
+    const synthesizedForwardCompat = [];
+    for (const candidate of ANTIGRAVITY_OPUS_46_FORWARD_COMPAT_CANDIDATES) {
+        const key = modelKey("google-antigravity", candidate.id);
+        const hasForwardCompat = nextModels.some((model) => modelKey(model.provider, model.id) === key);
+        if (hasForwardCompat) {
+            continue;
+        }
+        const fallback = resolveForwardCompatModel("google-antigravity", candidate.id, modelRegistry);
+        if (!fallback) {
+            continue;
+        }
+        nextModels.push(fallback);
+        synthesizedForwardCompat.push({
+            key,
+            templatePrefixes: candidate.templatePrefixes,
+        });
+    }
+    return { models: nextModels, synthesizedForwardCompat };
+}
+function hasAvailableTemplate(availableKeys, templatePrefixes) {
+    for (const key of availableKeys) {
+        if (templatePrefixes.some((prefix) => key.startsWith(prefix))) {
+            return true;
+        }
+    }
+    return false;
 }
 export function toModelRow(params) {
     const { model, key, tags, aliases = [], availableKeys, cfg, authStore } = params;
@@ -55,18 +141,24 @@ export function toModelRow(params) {
     }
     const input = model.input.join("+") || "text";
     const local = isLocalBaseUrl(model.baseUrl);
-    const available = cfg && authStore
-        ? hasAuthForProvider(model.provider, cfg, authStore)
-        : (availableKeys?.has(modelKey(model.provider, model.id)) ?? false);
+    // Prefer model-level registry availability when present.
+    // Fall back to provider-level auth heuristics only if registry availability isn't available.
+    const available = availableKeys !== undefined
+        ? availableKeys.has(modelKey(model.provider, model.id))
+        : cfg && authStore
+            ? hasAuthForProvider(model.provider, cfg, authStore)
+            : false;
     const aliasTags = aliases.length > 0 ? [`alias:${aliases.join(",")}`] : [];
     const mergedTags = new Set(tags);
     if (aliasTags.length > 0) {
         for (const tag of mergedTags) {
-            if (tag === "alias" || tag.startsWith("alias:"))
+            if (tag === "alias" || tag.startsWith("alias:")) {
                 mergedTags.delete(tag);
+            }
         }
-        for (const tag of aliasTags)
+        for (const tag of aliasTags) {
             mergedTags.add(tag);
+        }
     }
     return {
         key,

package/dist/commands/models/list.status-command.js

@@ -89,6 +89,7 @@ export async function modelsStatusCommand(opts, runtime) {
         "zai",
         "mistral",
         "synthetic",
+        "nvidia",
     ];
     for (const provider of envProbeProviders) {
         if (resolveEnvApiKey(provider))

package/dist/commands/models/shared.js

@@ -82,6 +82,20 @@ export function resolveKnownAgentId(params) {
     }
     return agentId;
 }
+export const isLocalBaseUrl = (baseUrl) => {
+    try {
+        const url = new URL(baseUrl);
+        const host = url.hostname.toLowerCase();
+        return (host === "localhost" ||
+            host === "127.0.0.1" ||
+            host === "0.0.0.0" ||
+            host === "::1" ||
+            host.endsWith(".local"));
+    }
+    catch {
+        return false;
+    }
+};
 export { modelKey };
 export { DEFAULT_MODEL, DEFAULT_PROVIDER };
 /**

package/dist/commands/onboard-auth.config-core.js

@@ -3,8 +3,8 @@ import { buildQianfanProvider, buildXiaomiProvider, QIANFAN_DEFAULT_MODEL_ID, XI
 import { buildSyntheticModelDefinition, SYNTHETIC_BASE_URL, SYNTHETIC_DEFAULT_MODEL_REF, SYNTHETIC_MODEL_CATALOG, } from "../agents/synthetic-models.js";
 import { buildTogetherModelDefinition, TOGETHER_BASE_URL, TOGETHER_MODEL_CATALOG, } from "../agents/together-models.js";
 import { buildVeniceModelDefinition, VENICE_BASE_URL, VENICE_DEFAULT_MODEL_REF, VENICE_MODEL_CATALOG, } from "../agents/venice-models.js";
-import { CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, OPENROUTER_DEFAULT_MODEL_REF, TOGETHER_DEFAULT_MODEL_REF, VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, XIAOMI_DEFAULT_MODEL_REF, ZAI_DEFAULT_MODEL_REF, XAI_DEFAULT_MODEL_REF, } from "./onboard-auth.credentials.js";
-import { buildMoonshotModelDefinition, buildXaiModelDefinition, QIANFAN_BASE_URL, QIANFAN_DEFAULT_MODEL_REF, KIMI_CODING_MODEL_REF, MOONSHOT_BASE_URL, MOONSHOT_CN_BASE_URL, MOONSHOT_DEFAULT_MODEL_ID, MOONSHOT_DEFAULT_MODEL_REF, XAI_BASE_URL, XAI_DEFAULT_MODEL_ID, } from "./onboard-auth.models.js";
+import { CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, OPENROUTER_DEFAULT_MODEL_REF, TOGETHER_DEFAULT_MODEL_REF, VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, XIAOMI_DEFAULT_MODEL_REF, ZAI_DEFAULT_MODEL_REF, XAI_DEFAULT_MODEL_REF, NVIDIA_DEFAULT_MODEL_REF, } from "./onboard-auth.credentials.js";
+import { buildMoonshotModelDefinition, buildNvidiaModelDefinition, buildXaiModelDefinition, QIANFAN_BASE_URL, QIANFAN_DEFAULT_MODEL_REF, KIMI_CODING_MODEL_REF, MOONSHOT_BASE_URL, MOONSHOT_CN_BASE_URL, MOONSHOT_DEFAULT_MODEL_ID, MOONSHOT_DEFAULT_MODEL_REF, NVIDIA_BASE_URL, NVIDIA_DEFAULT_MODEL_ID, XAI_BASE_URL, XAI_DEFAULT_MODEL_ID, } from "./onboard-auth.models.js";
 export function applyZaiConfig(cfg) {
     const models = { ...cfg.agents?.defaults?.models };
     models[ZAI_DEFAULT_MODEL_REF] = {
@@ -722,3 +722,61 @@ export function applyQianfanConfig(cfg) {
         },
     };
 }
+export function applyNvidiaProviderConfig(cfg) {
+    const models = { ...cfg.agents?.defaults?.models };
+    models[NVIDIA_DEFAULT_MODEL_REF] = {
+        ...models[NVIDIA_DEFAULT_MODEL_REF],
+        alias: models[NVIDIA_DEFAULT_MODEL_REF]?.alias ?? "Nemotron",
+    };
+    const providers = { ...cfg.models?.providers };
+    const existingProvider = providers.nvidia;
+    const existingModels = Array.isArray(existingProvider?.models) ? existingProvider.models : [];
+    const defaultModel = buildNvidiaModelDefinition();
+    const hasDefaultModel = existingModels.some((model) => model.id === NVIDIA_DEFAULT_MODEL_ID);
+    const mergedModels = hasDefaultModel ? existingModels : [...existingModels, defaultModel];
+    const { apiKey: existingApiKey, ...existingProviderRest } = (existingProvider ?? {});
+    const resolvedApiKey = typeof existingApiKey === "string" ? existingApiKey : undefined;
+    const normalizedApiKey = resolvedApiKey?.trim();
+    providers.nvidia = {
+        ...existingProviderRest,
+        baseUrl: NVIDIA_BASE_URL,
+        api: "openai-completions",
+        ...(normalizedApiKey ? { apiKey: normalizedApiKey } : {}),
+        models: mergedModels.length > 0 ? mergedModels : [defaultModel],
+    };
+    return {
+        ...cfg,
+        agents: {
+            ...cfg.agents,
+            defaults: {
+                ...cfg.agents?.defaults,
+                models,
+            },
+        },
+        models: {
+            mode: cfg.models?.mode ?? "merge",
+            providers,
+        },
+    };
+}
+export function applyNvidiaConfig(cfg) {
+    const next = applyNvidiaProviderConfig(cfg);
+    const existingModel = next.agents?.defaults?.model;
+    return {
+        ...next,
+        agents: {
+            ...next.agents,
+            defaults: {
+                ...next.agents?.defaults,
+                model: {
+                    ...(existingModel && "fallbacks" in existingModel
+                        ? {
+                            fallbacks: existingModel.fallbacks,
+                        }
+                        : undefined),
+                    primary: NVIDIA_DEFAULT_MODEL_REF,
+                },
+            },
+        },
+    };
+}

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

@@ -1,7 +1,7 @@
 import { resolvePoolbotAgentDir } from "../agents/agent-paths.js";
 import { upsertAuthProfile } from "../agents/auth-profiles.js";
 export { CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF } from "../agents/cloudflare-ai-gateway.js";
-export { XAI_DEFAULT_MODEL_REF } from "./onboard-auth.models.js";
+export { XAI_DEFAULT_MODEL_REF, NVIDIA_DEFAULT_MODEL_REF } from "./onboard-auth.models.js";
 const resolveAuthAgentDir = (agentDir) => agentDir ?? resolvePoolbotAgentDir();
 export async function writeOAuthCredentials(provider, creds, agentDir) {
     const email = typeof creds.email === "string" && creds.email.trim() ? creds.email.trim() : "default";
@@ -207,3 +207,14 @@ export function setXaiApiKey(key, agentDir) {
         agentDir: resolveAuthAgentDir(agentDir),
     });
 }
+export function setNvidiaApiKey(key, agentDir) {
+    upsertAuthProfile({
+        profileId: "nvidia:default",
+        credential: {
+            type: "api_key",
+            provider: "nvidia",
+            key,
+        },
+        agentDir: resolveAuthAgentDir(agentDir),
+    });
+}

package/dist/commands/onboard-auth.js

@@ -1,7 +1,7 @@
 export { SYNTHETIC_DEFAULT_MODEL_ID, SYNTHETIC_DEFAULT_MODEL_REF, } from "../agents/synthetic-models.js";
 export { VENICE_DEFAULT_MODEL_ID, VENICE_DEFAULT_MODEL_REF } from "../agents/venice-models.js";
-export { applyAuthProfileConfig, applyCloudflareAiGatewayConfig, applyCloudflareAiGatewayProviderConfig, applyQianfanConfig, applyQianfanProviderConfig, applyKimiCodeConfig, applyKimiCodeProviderConfig, applyMoonshotConfig, applyMoonshotConfigCn, applyMoonshotProviderConfig, applyMoonshotProviderConfigCn, applyOpenrouterConfig, applyOpenrouterProviderConfig, applySyntheticConfig, applySyntheticProviderConfig, applyTogetherConfig, applyTogetherProviderConfig, applyVeniceConfig, applyVeniceProviderConfig, applyVercelAiGatewayConfig, applyVercelAiGatewayProviderConfig, applyXaiConfig, applyXaiProviderConfig, applyXiaomiConfig, applyXiaomiProviderConfig, applyZaiConfig, } from "./onboard-auth.config-core.js";
+export { applyAuthProfileConfig, applyCloudflareAiGatewayConfig, applyCloudflareAiGatewayProviderConfig, applyQianfanConfig, applyQianfanProviderConfig, applyKimiCodeConfig, applyKimiCodeProviderConfig, applyMoonshotConfig, applyMoonshotConfigCn, applyMoonshotProviderConfig, applyMoonshotProviderConfigCn, applyOpenrouterConfig, applyOpenrouterProviderConfig, applySyntheticConfig, applySyntheticProviderConfig, applyTogetherConfig, applyTogetherProviderConfig, applyVeniceConfig, applyVeniceProviderConfig, applyVercelAiGatewayConfig, applyVercelAiGatewayProviderConfig, applyNvidiaConfig, applyNvidiaProviderConfig, applyXaiConfig, applyXaiProviderConfig, applyXiaomiConfig, applyXiaomiProviderConfig, applyZaiConfig, } from "./onboard-auth.config-core.js";
 export { applyMinimaxApiConfig, applyMinimaxApiProviderConfig, applyMinimaxConfig, applyMinimaxHostedConfig, applyMinimaxHostedProviderConfig, applyMinimaxProviderConfig, } from "./onboard-auth.config-minimax.js";
 export { applyOpencodeZenConfig, applyOpencodeZenProviderConfig, } from "./onboard-auth.config-opencode.js";
-export { CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, OPENROUTER_DEFAULT_MODEL_REF, setAnthropicApiKey, setCloudflareAiGatewayConfig, setQianfanApiKey, setGeminiApiKey, setKimiCodingApiKey, setMinimaxApiKey, setMoonshotApiKey, setOpencodeZenApiKey, setOpenrouterApiKey, setSyntheticApiKey, setTogetherApiKey, setVeniceApiKey, setVercelAiGatewayApiKey, setXiaomiApiKey, setZaiApiKey, setXaiApiKey, writeOAuthCredentials, VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, XIAOMI_DEFAULT_MODEL_REF, ZAI_DEFAULT_MODEL_REF, TOGETHER_DEFAULT_MODEL_REF, XAI_DEFAULT_MODEL_REF, } from "./onboard-auth.credentials.js";
-export { buildMinimaxApiModelDefinition, buildMinimaxModelDefinition, buildMoonshotModelDefinition, DEFAULT_MINIMAX_BASE_URL, MOONSHOT_CN_BASE_URL, QIANFAN_BASE_URL, QIANFAN_DEFAULT_MODEL_ID, QIANFAN_DEFAULT_MODEL_REF, KIMI_CODING_MODEL_ID, KIMI_CODING_MODEL_REF, MINIMAX_API_BASE_URL, MINIMAX_HOSTED_MODEL_ID, MINIMAX_HOSTED_MODEL_REF, MOONSHOT_BASE_URL, MOONSHOT_DEFAULT_MODEL_ID, MOONSHOT_DEFAULT_MODEL_REF, } from "./onboard-auth.models.js";
+export { CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, OPENROUTER_DEFAULT_MODEL_REF, setAnthropicApiKey, setCloudflareAiGatewayConfig, setQianfanApiKey, setGeminiApiKey, setKimiCodingApiKey, setMinimaxApiKey, setMoonshotApiKey, setOpencodeZenApiKey, setOpenrouterApiKey, setSyntheticApiKey, setTogetherApiKey, setVeniceApiKey, setVercelAiGatewayApiKey, setXiaomiApiKey, setZaiApiKey, setNvidiaApiKey, setXaiApiKey, writeOAuthCredentials, VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, NVIDIA_DEFAULT_MODEL_REF, XIAOMI_DEFAULT_MODEL_REF, ZAI_DEFAULT_MODEL_REF, TOGETHER_DEFAULT_MODEL_REF, XAI_DEFAULT_MODEL_REF, } from "./onboard-auth.credentials.js";
+export { buildMinimaxApiModelDefinition, buildMinimaxModelDefinition, buildMoonshotModelDefinition, DEFAULT_MINIMAX_BASE_URL, MOONSHOT_CN_BASE_URL, QIANFAN_BASE_URL, QIANFAN_DEFAULT_MODEL_ID, QIANFAN_DEFAULT_MODEL_REF, KIMI_CODING_MODEL_ID, KIMI_CODING_MODEL_REF, MINIMAX_API_BASE_URL, MINIMAX_HOSTED_MODEL_ID, MINIMAX_HOSTED_MODEL_REF, MOONSHOT_BASE_URL, MOONSHOT_DEFAULT_MODEL_ID, MOONSHOT_DEFAULT_MODEL_REF, buildNvidiaModelDefinition, NVIDIA_BASE_URL, NVIDIA_DEFAULT_MODEL_ID, } from "./onboard-auth.models.js";

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

@@ -100,3 +100,25 @@ export function buildXaiModelDefinition() {
         maxTokens: XAI_DEFAULT_MAX_TOKENS,
     };
 }
+export const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+export const NVIDIA_DEFAULT_MODEL_ID = "llama-3.1-nemotron-ultra-253b-v1";
+export const NVIDIA_DEFAULT_MODEL_REF = `nvidia/${NVIDIA_DEFAULT_MODEL_ID}`;
+export const NVIDIA_DEFAULT_CONTEXT_WINDOW = 131072;
+export const NVIDIA_DEFAULT_MAX_TOKENS = 8192;
+export const NVIDIA_DEFAULT_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+export function buildNvidiaModelDefinition() {
+    return {
+        id: NVIDIA_DEFAULT_MODEL_ID,
+        name: "Nemotron Ultra 253B",
+        reasoning: false,
+        input: ["text"],
+        cost: NVIDIA_DEFAULT_COST,
+        contextWindow: NVIDIA_DEFAULT_CONTEXT_WINDOW,
+        maxTokens: NVIDIA_DEFAULT_MAX_TOKENS,
+    };
+}

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

@@ -16,6 +16,7 @@ const AUTH_CHOICE_FLAG_MAP = [
     { flag: "zaiApiKey", authChoice: "zai-api-key", label: "--zai-api-key" },
     { flag: "xiaomiApiKey", authChoice: "xiaomi-api-key", label: "--xiaomi-api-key" },
     { flag: "xaiApiKey", authChoice: "xai-api-key", label: "--xai-api-key" },
+    { flag: "nvidiaApiKey", authChoice: "nvidia-api-key", label: "--nvidia-api-key" },
     { flag: "minimaxApiKey", authChoice: "minimax-api", label: "--minimax-api-key" },
     { flag: "opencodeZenApiKey", authChoice: "opencode-zen", label: "--opencode-zen-api-key" },
 ];

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

@@ -6,7 +6,7 @@ import { normalizeSecretInput } from "../../../utils/normalize-secret-input.js";
 import { buildTokenProfileId, validateAnthropicSetupToken } from "../../auth-token.js";
 import { applyGoogleGeminiModelDefault } from "../../google-gemini-model-default.js";
 import { applyOpenAIConfig } from "../../openai-model-default.js";
-import { applyAuthProfileConfig, applyCloudflareAiGatewayConfig, applyKimiCodeConfig, applyMinimaxApiConfig, applyMinimaxConfig, applyMoonshotConfig, applyMoonshotConfigCn, applyOpencodeZenConfig, applyOpenrouterConfig, applyQianfanConfig, applySyntheticConfig, applyTogetherConfig, applyVeniceConfig, applyVercelAiGatewayConfig, applyXaiConfig, applyXiaomiConfig, applyZaiConfig, setAnthropicApiKey, setCloudflareAiGatewayConfig, setGeminiApiKey, setKimiCodingApiKey, setMinimaxApiKey, setMoonshotApiKey, setOpencodeZenApiKey, setOpenrouterApiKey, setQianfanApiKey, setSyntheticApiKey, setTogetherApiKey, setVeniceApiKey, setVercelAiGatewayApiKey, setXaiApiKey, setXiaomiApiKey, setZaiApiKey, } from "../../onboard-auth.js";
+import { applyAuthProfileConfig, applyCloudflareAiGatewayConfig, applyKimiCodeConfig, applyMinimaxApiConfig, applyMinimaxConfig, applyMoonshotConfig, applyMoonshotConfigCn, applyOpencodeZenConfig, applyOpenrouterConfig, applyQianfanConfig, applySyntheticConfig, applyTogetherConfig, applyVeniceConfig, applyVercelAiGatewayConfig, applyNvidiaConfig, applyXaiConfig, applyXiaomiConfig, applyZaiConfig, setAnthropicApiKey, setCloudflareAiGatewayConfig, setGeminiApiKey, setKimiCodingApiKey, setMinimaxApiKey, setMoonshotApiKey, setNvidiaApiKey, setOpencodeZenApiKey, setOpenrouterApiKey, setQianfanApiKey, setSyntheticApiKey, setTogetherApiKey, setVeniceApiKey, setVercelAiGatewayApiKey, setXaiApiKey, setXiaomiApiKey, setZaiApiKey, } from "../../onboard-auth.js";
 import { resolveNonInteractiveApiKey } from "../api-keys.js";
 import { shortenHomePath } from "../../../utils.js";
 export async function applyNonInteractiveAuthChoice(params) {
@@ -358,6 +358,26 @@ export async function applyNonInteractiveAuthChoice(params) {
         });
         return applyQianfanConfig(nextConfig);
     }
+    if (authChoice === "nvidia-api-key") {
+        const resolved = await resolveNonInteractiveApiKey({
+            provider: "nvidia",
+            cfg: baseConfig,
+            flagValue: opts.nvidiaApiKey,
+            flagName: "--nvidia-api-key",
+            envVar: "NVIDIA_API_KEY",
+            runtime,
+        });
+        if (!resolved)
+            return null;
+        if (resolved.source !== "profile")
+            setNvidiaApiKey(resolved.key);
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId: "nvidia:default",
+            provider: "nvidia",
+            mode: "api_key",
+        });
+        return applyNvidiaConfig(nextConfig);
+    }
     if (authChoice === "cloudflare-ai-gateway-api-key") {
         const accountId = opts.cloudflareAiGatewayAccountId?.trim() ?? "";
         const gatewayId = opts.cloudflareAiGatewayGatewayId?.trim() ?? "";

package/dist/commands/provider-auth-helpers.js

@@ -0,0 +1,61 @@
+import { normalizeProviderId } from "../agents/model-selection.js";
+export function resolveProviderMatch(providers, rawProvider) {
+    const raw = rawProvider?.trim();
+    if (!raw) {
+        return null;
+    }
+    const normalized = normalizeProviderId(raw);
+    return (providers.find((provider) => normalizeProviderId(provider.id) === normalized) ??
+        providers.find((provider) => provider.aliases?.some((alias) => normalizeProviderId(alias) === normalized) ?? false) ??
+        null);
+}
+export function pickAuthMethod(provider, rawMethod) {
+    const raw = rawMethod?.trim();
+    if (!raw) {
+        return null;
+    }
+    const normalized = raw.toLowerCase();
+    return (provider.auth.find((method) => method.id.toLowerCase() === normalized) ??
+        provider.auth.find((method) => method.label.toLowerCase() === normalized) ??
+        null);
+}
+function isPlainRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+export function mergeConfigPatch(base, patch) {
+    if (!isPlainRecord(base) || !isPlainRecord(patch)) {
+        return patch;
+    }
+    const next = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        const existing = next[key];
+        if (isPlainRecord(existing) && isPlainRecord(value)) {
+            next[key] = mergeConfigPatch(existing, value);
+        }
+        else {
+            next[key] = value;
+        }
+    }
+    return next;
+}
+export function applyDefaultModel(cfg, model) {
+    const models = { ...cfg.agents?.defaults?.models };
+    models[model] = models[model] ?? {};
+    const existingModel = cfg.agents?.defaults?.model;
+    return {
+        ...cfg,
+        agents: {
+            ...cfg.agents,
+            defaults: {
+                ...cfg.agents?.defaults,
+                models,
+                model: {
+                    ...(existingModel && typeof existingModel === "object" && "fallbacks" in existingModel
+                        ? { fallbacks: existingModel.fallbacks }
+                        : undefined),
+                    primary: model,
+                },
+            },
+        },
+    };
+}

package/dist/terminal/theme.js

@@ -16,7 +16,7 @@ export const theme = {
     muted: hex(POOLBOT_PALETTE.muted),
     heading: baseChalk.bold.hex(POOLBOT_PALETTE.accent),
     command: hex(POOLBOT_PALETTE.accentBright),
-    option: hex(POOLBOT_PALETTE.warn),
+    option: hex(POOLBOT_PALETTE.info),
 };
 export const isRich = () => Boolean(baseChalk.level > 0);
 export const colorize = (rich, color, value) => rich ? color(value) : value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.2.4",
+  "version": "2026.2.5",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",