@poolzin/pool-bot 2026.2.4 → 2026.2.6

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

@@ -0,0 +1,77 @@
+import { ensureAuthProfileStore, resolveAuthProfileOrder } from "../agents/auth-profiles.js";
+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, applyOpenrouterConfig, applyOpenrouterProviderConfig, setOpenrouterApiKey, OPENROUTER_DEFAULT_MODEL_REF, } from "./onboard-auth.js";
+export async function applyAuthChoiceOpenRouter(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");
+    };
+    const store = ensureAuthProfileStore(params.agentDir, { allowKeychainPrompt: false });
+    const profileOrder = resolveAuthProfileOrder({
+        cfg: nextConfig,
+        store,
+        provider: "openrouter",
+    });
+    const existingProfileId = profileOrder.find((profileId) => Boolean(store.profiles[profileId]));
+    const existingCred = existingProfileId ? store.profiles[existingProfileId] : undefined;
+    let profileId = "openrouter:default";
+    let mode = "api_key";
+    let hasCredential = false;
+    if (existingProfileId && existingCred?.type) {
+        profileId = existingProfileId;
+        mode =
+            existingCred.type === "oauth" ? "oauth" : existingCred.type === "token" ? "token" : "api_key";
+        hasCredential = true;
+    }
+    if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "openrouter") {
+        await setOpenrouterApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
+        hasCredential = true;
+    }
+    if (!hasCredential) {
+        const envKey = resolveEnvApiKey("openrouter");
+        if (envKey) {
+            const useExisting = await params.prompter.confirm({
+                message: `Use existing OPENROUTER_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
+                initialValue: true,
+            });
+            if (useExisting) {
+                await setOpenrouterApiKey(envKey.apiKey, params.agentDir);
+                hasCredential = true;
+            }
+        }
+    }
+    if (!hasCredential) {
+        const key = await params.prompter.text({
+            message: "Enter OpenRouter API key",
+            validate: validateApiKeyInput,
+        });
+        await setOpenrouterApiKey(normalizeApiKeyInput(String(key ?? "")), params.agentDir);
+        hasCredential = true;
+    }
+    if (hasCredential) {
+        nextConfig = applyAuthProfileConfig(nextConfig, {
+            profileId,
+            provider: "openrouter",
+            mode,
+        });
+    }
+    const applied = await applyDefaultModelChoice({
+        config: nextConfig,
+        setDefaultModel: params.setDefaultModel,
+        defaultModel: OPENROUTER_DEFAULT_MODEL_REF,
+        applyDefaultConfig: applyOpenrouterConfig,
+        applyProviderConfig: applyOpenrouterProviderConfig,
+        noteDefault: OPENROUTER_DEFAULT_MODEL_REF,
+        noteAgentModel,
+        prompter: params.prompter,
+    });
+    nextConfig = applied.config;
+    agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
+    return { config: nextConfig, agentModelOverride };
+}

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.apply.vllm.js

@@ -0,0 +1,92 @@
+import { upsertAuthProfileWithLock } from "../agents/auth-profiles.js";
+const VLLM_DEFAULT_BASE_URL = "http://127.0.0.1:8000/v1";
+const VLLM_DEFAULT_CONTEXT_WINDOW = 128000;
+const VLLM_DEFAULT_MAX_TOKENS = 8192;
+const VLLM_DEFAULT_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+function applyVllmDefaultModel(cfg, modelRef) {
+    const existingModel = cfg.agents?.defaults?.model;
+    const fallbacks = existingModel && typeof existingModel === "object" && "fallbacks" in existingModel
+        ? existingModel.fallbacks
+        : undefined;
+    return {
+        ...cfg,
+        agents: {
+            ...cfg.agents,
+            defaults: {
+                ...cfg.agents?.defaults,
+                model: {
+                    ...(fallbacks ? { fallbacks } : undefined),
+                    primary: modelRef,
+                },
+            },
+        },
+    };
+}
+export async function applyAuthChoiceVllm(params) {
+    if (params.authChoice !== "vllm") {
+        return null;
+    }
+    const baseUrlRaw = await params.prompter.text({
+        message: "vLLM base URL",
+        initialValue: VLLM_DEFAULT_BASE_URL,
+        placeholder: VLLM_DEFAULT_BASE_URL,
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    });
+    const apiKeyRaw = await params.prompter.text({
+        message: "vLLM API key",
+        placeholder: "sk-... (or any non-empty string)",
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    });
+    const modelIdRaw = await params.prompter.text({
+        message: "vLLM model",
+        placeholder: "meta-llama/Meta-Llama-3-8B-Instruct",
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    });
+    const baseUrl = String(baseUrlRaw ?? "")
+        .trim()
+        .replace(/\/+$/, "");
+    const apiKey = String(apiKeyRaw ?? "").trim();
+    const modelId = String(modelIdRaw ?? "").trim();
+    const modelRef = `vllm/${modelId}`;
+    await upsertAuthProfileWithLock({
+        profileId: "vllm:default",
+        credential: { type: "api_key", provider: "vllm", key: apiKey },
+        agentDir: params.agentDir,
+    });
+    const nextConfig = {
+        ...params.config,
+        models: {
+            ...params.config.models,
+            mode: params.config.models?.mode ?? "merge",
+            providers: {
+                ...params.config.models?.providers,
+                vllm: {
+                    baseUrl,
+                    api: "openai-completions",
+                    apiKey: "VLLM_API_KEY",
+                    models: [
+                        {
+                            id: modelId,
+                            name: modelId,
+                            reasoning: false,
+                            input: ["text"],
+                            cost: VLLM_DEFAULT_COST,
+                            contextWindow: VLLM_DEFAULT_CONTEXT_WINDOW,
+                            maxTokens: VLLM_DEFAULT_MAX_TOKENS,
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    if (!params.setDefaultModel) {
+        return { config: nextConfig, agentModelOverride: modelRef };
+    }
+    await params.prompter.note(`Default model set to ${modelRef}`, "Model configured");
+    return { config: applyVllmDefaultModel(nextConfig, modelRef) };
+}

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

@@ -4,6 +4,7 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
     "claude-cli": "anthropic",
     token: "anthropic",
     apiKey: "anthropic",
+    vllm: "vllm",
     "openai-codex": "openai-codex",
     "codex-cli": "openai-codex",
     chutes: "chutes",
@@ -18,10 +19,15 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
     "google-antigravity": "google-antigravity",
     "google-gemini-cli": "google-gemini-cli",
     "zai-api-key": "zai",
+    "zai-coding-global": "zai",
+    "zai-coding-cn": "zai",
+    "zai-global": "zai",
+    "zai-cn": "zai",
     "xiaomi-api-key": "xiaomi",
     "synthetic-api-key": "synthetic",
     "venice-api-key": "venice",
     "together-api-key": "together",
+    "huggingface-api-key": "huggingface",
     "github-copilot": "github-copilot",
     "copilot-proxy": "copilot-proxy",
     "minimax-cloud": "minimax",
@@ -30,8 +36,12 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE = {
     minimax: "lmstudio",
     "opencode-zen": "opencode",
     "xai-api-key": "xai",
+    "litellm-api-key": "litellm",
     "qwen-portal": "qwen-portal",
+    "minimax-portal": "minimax-portal",
     "qianfan-api-key": "qianfan",
+    "nvidia-api-key": "nvidia",
+    "custom-api-key": "custom",
 };
 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 };
 /**