@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/commands/model-picker.js

@@ -5,26 +5,47 @@ import { loadModelCatalog } from "../agents/model-catalog.js";
 import { buildAllowedModelSet, buildModelAliasIndex, modelKey, normalizeProviderId, resolveConfiguredModelRef, } from "../agents/model-selection.js";
 import { formatTokenK } from "./models/shared.js";
 import { OPENAI_CODEX_DEFAULT_MODEL } from "./openai-codex-model-default.js";
+import { promptAndConfigureVllm } from "./vllm-setup.js";
 const KEEP_VALUE = "__keep__";
 const MANUAL_VALUE = "__manual__";
+const VLLM_VALUE = "__vllm__";
 const PROVIDER_FILTER_THRESHOLD = 30;
 // Models that are internal routing features and should not be shown in selection lists.
 // These may be valid as defaults (e.g., set automatically during auth flow) but are not
 // directly callable via API and would cause "Unknown model" errors if selected manually.
 const HIDDEN_ROUTER_MODELS = new Set(["openrouter/auto"]);
 function hasAuthForProvider(provider, cfg, store) {
-    if (listProfilesForProvider(store, provider).length > 0)
+    if (listProfilesForProvider(store, provider).length > 0) {
         return true;
-    if (resolveEnvApiKey(provider))
+    }
+    if (resolveEnvApiKey(provider)) {
         return true;
-    if (getCustomProviderApiKey(cfg, provider))
+    }
+    if (getCustomProviderApiKey(cfg, provider)) {
         return true;
+    }
     return false;
 }
+function createProviderAuthChecker(params) {
+    const authStore = ensureAuthProfileStore(params.agentDir, {
+        allowKeychainPrompt: false,
+    });
+    const authCache = new Map();
+    return (provider) => {
+        const cached = authCache.get(provider);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const value = hasAuthForProvider(provider, params.cfg, authStore);
+        authCache.set(provider, value);
+        return value;
+    };
+}
 function resolveConfiguredModelRaw(cfg) {
     const raw = cfg.agents?.defaults?.model;
-    if (typeof raw === "string")
+    if (typeof raw === "string") {
         return raw.trim();
+    }
     return raw?.primary?.trim() ?? "";
 }
 function resolveConfiguredModelKeys(cfg) {
@@ -38,13 +59,52 @@ function normalizeModelKeys(values) {
     const next = [];
     for (const raw of values) {
         const value = String(raw ?? "").trim();
-        if (!value || seen.has(value))
+        if (!value || seen.has(value)) {
             continue;
+        }
         seen.add(value);
         next.push(value);
     }
     return next;
 }
+function addModelSelectOption(params) {
+    const key = modelKey(params.entry.provider, params.entry.id);
+    if (params.seen.has(key)) {
+        return;
+    }
+    // Skip internal router models that can't be directly called via API.
+    if (HIDDEN_ROUTER_MODELS.has(key)) {
+        return;
+    }
+    const hints = [];
+    if (params.entry.name && params.entry.name !== params.entry.id) {
+        hints.push(params.entry.name);
+    }
+    if (params.entry.contextWindow) {
+        hints.push(`ctx ${formatTokenK(params.entry.contextWindow)}`);
+    }
+    if (params.entry.reasoning) {
+        hints.push("reasoning");
+    }
+    const aliases = params.aliasIndex.byKey.get(key);
+    if (aliases?.length) {
+        hints.push(`alias: ${aliases.join(", ")}`);
+    }
+    if (!params.hasAuth(params.entry.provider)) {
+        hints.push("auth missing");
+    }
+    params.options.push({
+        value: key,
+        label: key,
+        hint: hints.length > 0 ? hints.join(" · ") : undefined,
+    });
+    params.seen.add(key);
+}
+function isAnthropicLegacyModel(entry) {
+    return (entry.provider === "anthropic" &&
+        typeof entry.id === "string" &&
+        entry.id.toLowerCase().startsWith("claude-3"));
+}
 async function promptManualModel(params) {
     const modelInput = await params.prompter.text({
         message: params.allowBlank ? "Default model (blank to keep)" : "Default model",
@@ -53,14 +113,16 @@ async function promptManualModel(params) {
         validate: params.allowBlank ? undefined : (value) => (value?.trim() ? undefined : "Required"),
     });
     const model = String(modelInput ?? "").trim();
-    if (!model)
+    if (!model) {
         return {};
+    }
     return { model };
 }
 export async function promptDefaultModel(params) {
     const cfg = params.config;
     const allowKeep = params.allowKeep ?? true;
     const includeManual = params.includeManual ?? true;
+    const includeVllm = params.includeVllm ?? false;
     const ignoreAllowlist = params.ignoreAllowlist ?? false;
     const preferredProviderRaw = params.preferredProvider?.trim();
     const preferredProvider = preferredProviderRaw
@@ -102,7 +164,7 @@ export async function promptDefaultModel(params) {
             initialValue: configuredRaw || resolvedKey || undefined,
         });
     }
-    const providers = Array.from(new Set(models.map((entry) => entry.provider))).sort((a, b) => a.localeCompare(b));
+    const providers = Array.from(new Set(models.map((entry) => entry.provider))).toSorted((a, b) => a.localeCompare(b));
     const hasPreferredProvider = preferredProvider ? providers.includes(preferredProvider) : false;
     const shouldPromptProvider = !hasPreferredProvider && providers.length > 1 && models.length > PROVIDER_FILTER_THRESHOLD;
     if (shouldPromptProvider) {
@@ -126,19 +188,12 @@ export async function promptDefaultModel(params) {
     }
     if (hasPreferredProvider && preferredProvider) {
         models = models.filter((entry) => entry.provider === preferredProvider);
+        if (preferredProvider === "anthropic") {
+            models = models.filter((entry) => !isAnthropicLegacyModel(entry));
+        }
     }
-    const authStore = ensureAuthProfileStore(params.agentDir, {
-        allowKeychainPrompt: false,
-    });
-    const authCache = new Map();
-    const hasAuth = (provider) => {
-        const cached = authCache.get(provider);
-        if (cached !== undefined)
-            return cached;
-        const value = hasAuthForProvider(provider, cfg, authStore);
-        authCache.set(provider, value);
-        return value;
-    };
+    const agentDir = params.agentDir;
+    const hasAuth = createProviderAuthChecker({ cfg, agentDir });
     const options = [];
     if (allowKeep) {
         options.push({
@@ -152,35 +207,17 @@ export async function promptDefaultModel(params) {
     if (includeManual) {
         options.push({ value: MANUAL_VALUE, label: "Enter model manually" });
     }
-    const seen = new Set();
-    const addModelOption = (entry) => {
-        const key = modelKey(entry.provider, entry.id);
-        if (seen.has(key))
-            return;
-        // Skip internal router models that can't be directly called via API.
-        if (HIDDEN_ROUTER_MODELS.has(key))
-            return;
-        const hints = [];
-        if (entry.name && entry.name !== entry.id)
-            hints.push(entry.name);
-        if (entry.contextWindow)
-            hints.push(`ctx ${formatTokenK(entry.contextWindow)}`);
-        if (entry.reasoning)
-            hints.push("reasoning");
-        const aliases = aliasIndex.byKey.get(key);
-        if (aliases?.length)
-            hints.push(`alias: ${aliases.join(", ")}`);
-        if (!hasAuth(entry.provider))
-            hints.push("auth missing");
+    if (includeVllm && agentDir) {
         options.push({
-            value: key,
-            label: key,
-            hint: hints.length > 0 ? hints.join(" · ") : undefined,
+            value: VLLM_VALUE,
+            label: "vLLM (custom)",
+            hint: "Enter vLLM URL + API key + model",
         });
-        seen.add(key);
-    };
-    for (const entry of models)
-        addModelOption(entry);
+    }
+    const seen = new Set();
+    for (const entry of models) {
+        addModelSelectOption({ entry, options, seen, aliasIndex, hasAuth });
+    }
     if (configuredKey && !seen.has(configuredKey)) {
         options.push({
             value: configuredKey,
@@ -203,8 +240,9 @@ export async function promptDefaultModel(params) {
         options,
         initialValue,
     });
-    if (selection === KEEP_VALUE)
+    if (selection === KEEP_VALUE) {
         return {};
+    }
     if (selection === MANUAL_VALUE) {
         return promptManualModel({
             prompter: params.prompter,
@@ -212,6 +250,18 @@ export async function promptDefaultModel(params) {
             initialValue: configuredRaw || resolvedKey || undefined,
         });
     }
+    if (selection === VLLM_VALUE) {
+        if (!agentDir) {
+            await params.prompter.note("vLLM setup requires an agent directory context.", "vLLM not available");
+            return {};
+        }
+        const { config: nextConfig, modelRef } = await promptAndConfigureVllm({
+            cfg,
+            prompter: params.prompter,
+            agentDir,
+        });
+        return { model: modelRef, config: nextConfig };
+    }
     return { model: String(selection) };
 }
 export async function promptModelAllowlist(params) {
@@ -245,62 +295,29 @@ export async function promptModelAllowlist(params) {
             .split(",")
             .map((value) => value.trim())
             .filter((value) => value.length > 0);
-        if (parsed.length === 0)
+        if (parsed.length === 0) {
             return {};
+        }
         return { models: normalizeModelKeys(parsed) };
     }
     const aliasIndex = buildModelAliasIndex({
         cfg,
         defaultProvider: DEFAULT_PROVIDER,
     });
-    const authStore = ensureAuthProfileStore(params.agentDir, {
-        allowKeychainPrompt: false,
-    });
-    const authCache = new Map();
-    const hasAuth = (provider) => {
-        const cached = authCache.get(provider);
-        if (cached !== undefined)
-            return cached;
-        const value = hasAuthForProvider(provider, cfg, authStore);
-        authCache.set(provider, value);
-        return value;
-    };
+    const hasAuth = createProviderAuthChecker({ cfg, agentDir: params.agentDir });
     const options = [];
     const seen = new Set();
-    const addModelOption = (entry) => {
-        const key = modelKey(entry.provider, entry.id);
-        if (seen.has(key))
-            return;
-        if (HIDDEN_ROUTER_MODELS.has(key))
-            return;
-        const hints = [];
-        if (entry.name && entry.name !== entry.id)
-            hints.push(entry.name);
-        if (entry.contextWindow)
-            hints.push(`ctx ${formatTokenK(entry.contextWindow)}`);
-        if (entry.reasoning)
-            hints.push("reasoning");
-        const aliases = aliasIndex.byKey.get(key);
-        if (aliases?.length)
-            hints.push(`alias: ${aliases.join(", ")}`);
-        if (!hasAuth(entry.provider))
-            hints.push("auth missing");
-        options.push({
-            value: key,
-            label: key,
-            hint: hints.length > 0 ? hints.join(" · ") : undefined,
-        });
-        seen.add(key);
-    };
     const filteredCatalog = allowedKeySet
         ? catalog.filter((entry) => allowedKeySet.has(modelKey(entry.provider, entry.id)))
         : catalog;
-    for (const entry of filteredCatalog)
-        addModelOption(entry);
+    for (const entry of filteredCatalog) {
+        addModelSelectOption({ entry, options, seen, aliasIndex, hasAuth });
+    }
     const supplementalKeys = allowedKeySet ? allowedKeys : existingKeys;
     for (const key of supplementalKeys) {
-        if (seen.has(key))
+        if (seen.has(key)) {
             continue;
+        }
         options.push({
             value: key,
             label: key,
@@ -308,24 +325,29 @@ export async function promptModelAllowlist(params) {
         });
         seen.add(key);
     }
-    if (options.length === 0)
+    if (options.length === 0) {
         return {};
+    }
     const selection = await params.prompter.multiselect({
         message: params.message ?? "Models in /model picker (multi-select)",
         options,
         initialValues: initialKeys.length > 0 ? initialKeys : undefined,
+        searchable: true,
     });
     const selected = normalizeModelKeys(selection.map((value) => String(value)));
-    if (selected.length > 0)
+    if (selected.length > 0) {
         return { models: selected };
-    if (existingKeys.length === 0)
+    }
+    if (existingKeys.length === 0) {
         return { models: [] };
+    }
     const confirmClear = await params.prompter.confirm({
         message: "Clear the model allowlist? (shows all models)",
         initialValue: false,
     });
-    if (!confirmClear)
+    if (!confirmClear) {
         return {};
+    }
     return { models: [] };
 }
 export function applyPrimaryModel(cfg, model) {
@@ -357,8 +379,9 @@ export function applyModelAllowlist(cfg, models) {
     const defaults = cfg.agents?.defaults;
     const normalized = normalizeModelKeys(models);
     if (normalized.length === 0) {
-        if (!defaults?.models)
+        if (!defaults?.models) {
             return cfg;
+        }
         const { models: _ignored, ...restDefaults } = defaults;
         return {
             ...cfg,
@@ -386,16 +409,18 @@ export function applyModelAllowlist(cfg, models) {
 }
 export function applyModelFallbacksFromSelection(cfg, selection) {
     const normalized = normalizeModelKeys(selection);
-    if (normalized.length <= 1)
+    if (normalized.length <= 1) {
         return cfg;
+    }
     const resolved = resolveConfiguredModelRef({
         cfg,
         defaultProvider: DEFAULT_PROVIDER,
         defaultModel: DEFAULT_MODEL,
     });
     const resolvedKey = modelKey(resolved.provider, resolved.model);
-    if (!normalized.includes(resolvedKey))
+    if (!normalized.includes(resolvedKey)) {
         return cfg;
+    }
     const defaults = cfg.agents?.defaults;
     const existingModel = defaults?.model;
     const existingPrimary = typeof existingModel === "string"

package/dist/commands/models/set.js

@@ -1,27 +1,8 @@
 import { logConfigUpdated } from "../../config/logging.js";
-import { resolveModelTarget, updateConfig } from "./shared.js";
+import { applyDefaultModelPrimaryUpdate, updateConfig } from "./shared.js";
 export async function modelsSetCommand(modelRaw, runtime) {
     const updated = await updateConfig((cfg) => {
-        const resolved = resolveModelTarget({ raw: modelRaw, cfg });
-        const key = `${resolved.provider}/${resolved.model}`;
-        const nextModels = { ...cfg.agents?.defaults?.models };
-        if (!nextModels[key])
-            nextModels[key] = {};
-        const existingModel = cfg.agents?.defaults?.model;
-        return {
-            ...cfg,
-            agents: {
-                ...cfg.agents,
-                defaults: {
-                    ...cfg.agents?.defaults,
-                    model: {
-                        ...(existingModel?.fallbacks ? { fallbacks: existingModel.fallbacks } : undefined),
-                        primary: key,
-                    },
-                    models: nextModels,
-                },
-            },
-        };
+        return applyDefaultModelPrimaryUpdate({ cfg, modelRaw, field: "model" });
     });
     logConfigUpdated(runtime);
     runtime.log(`Default model: ${updated.agents?.defaults?.model?.primary ?? modelRaw}`);

package/dist/commands/models/shared.js

@@ -10,21 +10,40 @@ export const ensureFlagCompatibility = (opts) => {
     }
 };
 export const formatTokenK = (value) => {
-    if (!value || !Number.isFinite(value))
+    if (!value || !Number.isFinite(value)) {
         return "-";
-    if (value < 1024)
+    }
+    if (value < 1024) {
         return `${Math.round(value)}`;
+    }
     return `${Math.round(value / 1024)}k`;
 };
 export const formatMs = (value) => {
-    if (value === null || value === undefined)
+    if (value === null || value === undefined) {
         return "-";
-    if (!Number.isFinite(value))
+    }
+    if (!Number.isFinite(value)) {
         return "-";
-    if (value < 1000)
+    }
+    if (value < 1000) {
         return `${Math.round(value)}ms`;
+    }
     return `${Math.round(value / 100) / 10}s`;
 };
+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 async function updateConfig(mutator) {
     const snapshot = await readConfigFileSnapshot();
     if (!snapshot.valid) {
@@ -50,21 +69,37 @@ export function resolveModelTarget(params) {
     }
     return resolved.ref;
 }
+export function resolveModelKeysFromEntries(params) {
+    const aliasIndex = buildModelAliasIndex({
+        cfg: params.cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+    });
+    return params.entries
+        .map((entry) => resolveModelRefFromString({
+        raw: entry,
+        defaultProvider: DEFAULT_PROVIDER,
+        aliasIndex,
+    }))
+        .filter((entry) => Boolean(entry))
+        .map((entry) => modelKey(entry.ref.provider, entry.ref.model));
+}
 export function buildAllowlistSet(cfg) {
     const allowed = new Set();
     const models = cfg.agents?.defaults?.models ?? {};
     for (const raw of Object.keys(models)) {
         const parsed = parseModelRef(String(raw ?? ""), DEFAULT_PROVIDER);
-        if (!parsed)
+        if (!parsed) {
             continue;
+        }
         allowed.add(modelKey(parsed.provider, parsed.model));
     }
     return allowed;
 }
 export function normalizeAlias(alias) {
     const trimmed = alias.trim();
-    if (!trimmed)
+    if (!trimmed) {
         throw new Error("Alias cannot be empty.");
+    }
     if (!/^[A-Za-z0-9_.:-]+$/.test(trimmed)) {
         throw new Error("Alias must use letters, numbers, dots, underscores, colons, or dashes.");
     }
@@ -82,36 +117,6 @@ 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 };
-export function resolveModelKeysFromEntries(params) {
-    const aliasIndex = buildModelAliasIndex({
-        cfg: params.cfg,
-        defaultProvider: DEFAULT_PROVIDER,
-    });
-    return params.entries
-        .map((entry) => resolveModelRefFromString({
-        raw: entry,
-        defaultProvider: DEFAULT_PROVIDER,
-        aliasIndex,
-    }))
-        .filter((entry) => Boolean(entry))
-        .map((entry) => modelKey(entry.ref.provider, entry.ref.model));
-}
 export function mergePrimaryFallbackConfig(existing, patch) {
     const next = { ...existing };
     if (patch.primary !== undefined) {
@@ -122,6 +127,29 @@ export function mergePrimaryFallbackConfig(existing, patch) {
     }
     return next;
 }
+export function applyDefaultModelPrimaryUpdate(params) {
+    const resolved = resolveModelTarget({ raw: params.modelRaw, cfg: params.cfg });
+    const key = `${resolved.provider}/${resolved.model}`;
+    const nextModels = { ...params.cfg.agents?.defaults?.models };
+    if (!nextModels[key]) {
+        nextModels[key] = {};
+    }
+    const defaults = params.cfg.agents?.defaults ?? {};
+    const existing = defaults[params.field];
+    return {
+        ...params.cfg,
+        agents: {
+            ...params.cfg.agents,
+            defaults: {
+                ...defaults,
+                [params.field]: mergePrimaryFallbackConfig(existing, { primary: key }),
+                models: nextModels,
+            },
+        },
+    };
+}
+export { modelKey };
+export { DEFAULT_MODEL, DEFAULT_PROVIDER };
 /**
  * Model key format: "provider/model"
  *