zevairouter 1.1.18 → 1.1.20

package/cli/src/cli/utils/modelSelector.js

@@ -28,109 +28,277 @@ const PROVIDER_ALIAS_NAMES = {
 };
 
 /**
- * Get all available models grouped by provider + combos
- * @returns {Promise<{combos: Array, groups: Object}>}
+ * Normalize available models into combo and provider categories.
+ * The first valid row owns an exact model ID.
+ * @param {Array} models
+ * @param {Object} options
+ * @returns {{combos: string[], groups: Object<string, string[]>}}
  */
-async function getAvailableModelsGrouped() {
-  const result = await api.getAvailableModels();
-  if (!result.success) return { combos: [], groups: {} };
-  
-  const models = result.data?.data || [];
+function groupAvailableModels(models, { excludeCombos = false } = {}) {
   const combos = [];
   const groups = {};
-  
-  models.forEach(m => {
-    if (m.owned_by === "combo") {
-      combos.push(m.id);
-    } else {
-      const provider = m.owned_by;
-      if (!groups[provider]) {
-        groups[provider] = [];
-      }
-      groups[provider].push(m.id);
+  const seen = new Set();
+
+  if (!Array.isArray(models)) return { combos, groups };
+
+  for (const model of models) {
+    if (
+      !model ||
+      typeof model.id !== "string" ||
+      model.id.length === 0 ||
+      typeof model.owned_by !== "string" ||
+      model.owned_by.length === 0 ||
+      seen.has(model.id)
+    ) {
+      continue;
     }
-  });
-  
+
+    seen.add(model.id);
+    if (model.owned_by === "combo") {
+      if (!excludeCombos) combos.push(model.id);
+      continue;
+    }
+
+    if (!groups[model.owned_by]) groups[model.owned_by] = [];
+    groups[model.owned_by].push(model.id);
+  }
+
   return { combos, groups };
 }
 
 /**
- * Display model list and prompt for selection
- * @param {string} title - Title to display
- * @param {string} currentValue - Current selected value (optional)
- * @param {Object} options - { excludeCombos?: boolean }
- * @returns {Promise<string|null>} Selected model ID or null if cancelled
+ * Return provider IDs in configured alias order, then deterministic alphabetical order.
+ * @param {Object<string, string[]>} groups
+ * @returns {string[]}
  */
-async function selectModelFromList(title, currentValue = "", options = {}) {
-  const { excludeCombos = false } = options;
-  const { combos: rawCombos, groups } = await getAvailableModelsGrouped();
-  const combos = excludeCombos ? [] : rawCombos;
+function sortedProviderIds(groups) {
+  if (!groups || typeof groups !== "object") return [];
+
+  return Object.keys(groups).sort((left, right) => {
+    const leftLower = left.toLowerCase();
+    const rightLower = right.toLowerCase();
+    const leftIndex = PROVIDER_ALIAS_ORDER.indexOf(leftLower);
+    const rightIndex = PROVIDER_ALIAS_ORDER.indexOf(rightLower);
+    const leftKnown = leftIndex !== -1;
+    const rightKnown = rightIndex !== -1;
+
+    if (leftKnown && rightKnown && leftIndex !== rightIndex) return leftIndex - rightIndex;
+    if (leftKnown !== rightKnown) return leftKnown ? -1 : 1;
+    if (leftLower < rightLower) return -1;
+    if (leftLower > rightLower) return 1;
+    if (left < right) return -1;
+    if (left > right) return 1;
+    return 0;
+  });
+}
 
-  const totalModels = combos.length + Object.values(groups).flat().length;
-  if (totalModels === 0) {
-    return null;
+/**
+ * Search full model IDs in their display order.
+ * @param {{combos?: string[], groups?: Object<string, string[]>}} grouped
+ * @param {string} query
+ * @returns {string[]}
+ */
+function searchAvailableModels(grouped, query) {
+  if (typeof query !== "string" || query.trim() === "") return [];
+
+  const needle = query.trim().toLowerCase();
+  const matches = [];
+  const seen = new Set();
+  const groups = grouped?.groups && typeof grouped.groups === "object" ? grouped.groups : {};
+  const categories = [
+    ...(Array.isArray(grouped?.combos) ? [grouped.combos] : []),
+    ...sortedProviderIds(groups).map(provider => groups[provider]),
+  ];
+
+  for (const models of categories) {
+    if (!Array.isArray(models)) continue;
+    for (const model of models) {
+      if (
+        typeof model === "string" &&
+        model.toLowerCase().includes(needle) &&
+        !seen.has(model)
+      ) {
+        seen.add(model);
+        matches.push(model);
+      }
+    }
   }
-  
-  // Build flat list for selection
-  const allModels = [];
-  
-  // Display
-  clearScreen();
+
+  return matches;
+}
+
+/**
+ * Get all available models grouped by provider + combos.
+ * @param {Object} options
+ * @returns {Promise<{combos: string[], groups: Object<string, string[]>}>}
+ */
+async function getAvailableModelsGrouped({
+  excludeCombos = false,
+  getModelsFn = api.getAvailableModels,
+} = {}) {
+  const result = await getModelsFn();
+  if (!result?.success || !Array.isArray(result.data?.data)) {
+    return { combos: [], groups: {} };
+  }
+  return groupAvailableModels(result.data.data, { excludeCombos });
+}
+
+function providerDisplayName(provider) {
+  return PROVIDER_ALIAS_NAMES[provider.toLowerCase()] || provider;
+}
+
+function renderHeading(clearScreenFn, title, currentValue) {
+  clearScreenFn();
   console.log(`\n🎯 ${title}`);
   console.log("=".repeat(50));
-  if (currentValue) {
-    console.log(`Current: ${currentValue}\n`);
-  } else {
-    console.log();
-  }
-  
-  let idx = 1;
-  
-  // Combos first (skipped when excludeCombos is true)
-  if (combos.length > 0) {
-    console.log("[Combos]");
-    combos.forEach(combo => {
-      console.log(`  ${idx}. ${combo}`);
-      allModels.push(combo);
-      idx++;
-    });
-    console.log();
+  if (currentValue) console.log(`Current: ${currentValue}\n`);
+  else console.log();
+}
+
+function renderModelChoices(clearScreenFn, title, currentValue, label, models) {
+  renderHeading(clearScreenFn, title, currentValue);
+  console.log(`[${label}]`);
+  for (let index = 0; index < models.length; index++) {
+    console.log(`  ${index + 1}. ${models[index]}`);
   }
-  
-  // Provider groups in order (by alias)
-  const sortedProviders = Object.keys(groups).sort((a, b) => {
-    const idxA = PROVIDER_ALIAS_ORDER.indexOf(a);
-    const idxB = PROVIDER_ALIAS_ORDER.indexOf(b);
-    return (idxA === -1 ? 999 : idxA) - (idxB === -1 ? 999 : idxB);
-  });
-  
-  sortedProviders.forEach(provider => {
-    const providerName = PROVIDER_ALIAS_NAMES[provider] || provider;
-    console.log(`[${providerName}]`);
-    groups[provider].forEach(model => {
-      console.log(`  ${idx}. ${model}`);
-      allModels.push(model);
-      idx++;
-    });
-    console.log();
-  });
-  
-  console.log("  0. Cancel\n");
-  
-  // Prompt for number input
-  const input = await prompt("Enter number: ");
-  const num = parseInt(input, 10);
-  
-  if (isNaN(num) || num === 0 || num < 0 || num > allModels.length) {
-    return null;
+  console.log("\n  0. Back\n");
+}
+
+function strictSelection(input) {
+  const value = String(input ?? "").trim();
+  return /^\d+$/.test(value) ? Number(value) : null;
+}
+
+function isMalformedNumericInput(input) {
+  return /^[+-]?(?:\d|\.\d)/.test(String(input ?? "").trim());
+}
+
+/**
+ * Display a grouped model selector and prompt until a model is selected or cancelled.
+ * @param {string} title
+ * @param {string} currentValue
+ * @param {Object} options
+ * @returns {Promise<string|null>}
+ */
+async function selectModelFromList(title, currentValue = "", options = {}) {
+  const {
+    excludeCombos = false,
+    promptFn = prompt,
+    clearScreenFn = clearScreen,
+    getModelsFn = api.getAvailableModels,
+  } = options;
+  const grouped = await getAvailableModelsGrouped({ excludeCombos, getModelsFn });
+  const providers = sortedProviderIds(grouped.groups);
+  const totalModels = grouped.combos.length + providers.reduce(
+    (total, provider) => total + grouped.groups[provider].length,
+    0,
+  );
+  if (totalModels === 0) return null;
+
+  let state = "category";
+  let activeLabel = "";
+  let activeModels = [];
+  let searchNeedsQuery = false;
+
+  while (true) {
+    if (state === "category") {
+      const categories = [];
+      if (grouped.combos.length > 0) {
+        categories.push({ type: "provider", label: "Combos", models: grouped.combos });
+      }
+      for (const provider of providers) {
+        categories.push({
+          type: "provider",
+          label: providerDisplayName(provider),
+          models: grouped.groups[provider],
+        });
+      }
+      categories.push({ type: "search", label: "Search" });
+      categories.push({ type: "custom", label: "Custom model ID" });
+
+      renderHeading(clearScreenFn, title, currentValue);
+      for (let index = 0; index < categories.length; index++) {
+        const category = categories[index];
+        const count = category.models ? ` (${category.models.length})` : "";
+        console.log(`  ${index + 1}. ${category.label}${count}`);
+      }
+      console.log("\n  0. Cancel\n");
+
+      const input = String(await promptFn("Enter number or search: ") ?? "").trim();
+      const selection = strictSelection(input);
+      if (selection === 0) return null;
+      if (selection !== null) {
+        const category = categories[selection - 1];
+        if (!category) continue;
+        if (category.type === "provider") {
+          activeLabel = category.label;
+          activeModels = category.models;
+          state = "provider";
+        } else if (category.type === "search") {
+          searchNeedsQuery = true;
+          state = "search";
+        } else {
+          state = "custom";
+        }
+        continue;
+      }
+      if (input === "" || isMalformedNumericInput(input)) continue;
+      activeModels = searchAvailableModels(grouped, input);
+      activeLabel = "Search results";
+      searchNeedsQuery = false;
+      state = "search";
+      continue;
+    }
+
+    if (state === "provider") {
+      renderModelChoices(clearScreenFn, title, currentValue, activeLabel, activeModels);
+      const selection = strictSelection(await promptFn("Enter number: "));
+      if (selection === 0) {
+        state = "category";
+      } else if (selection !== null && selection <= activeModels.length) {
+        return activeModels[selection - 1];
+      }
+      continue;
+    }
+
+    if (state === "search") {
+      if (searchNeedsQuery) {
+        renderHeading(clearScreenFn, title, currentValue);
+        console.log("[Search]\n");
+        const query = String(await promptFn("Search query: ") ?? "").trim();
+        if (query === "") {
+          state = "category";
+          continue;
+        }
+        activeModels = searchAvailableModels(grouped, query);
+        activeLabel = "Search results";
+        searchNeedsQuery = false;
+      }
+
+      renderModelChoices(clearScreenFn, title, currentValue, activeLabel, activeModels);
+      const selection = strictSelection(await promptFn("Enter number: "));
+      if (selection === 0) {
+        state = "category";
+      } else if (selection !== null && selection <= activeModels.length) {
+        return activeModels[selection - 1];
+      }
+      continue;
+    }
+
+    renderHeading(clearScreenFn, title, currentValue);
+    console.log("[Custom model ID]\n");
+    const customModel = String(await promptFn("Model ID: ") ?? "").trim();
+    if (customModel !== "") return customModel;
+    state = "category";
   }
-  
-  return allModels[num - 1];
 }
 
 module.exports = {
   selectModelFromList,
   getAvailableModelsGrouped,
+  groupAvailableModels,
+  searchAvailableModels,
+  sortedProviderIds,
   PROVIDER_ALIAS_ORDER,
-  PROVIDER_ALIAS_NAMES
+  PROVIDER_ALIAS_NAMES,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.1.18",
+  "version": "1.1.20",
   "description": "Self-hosted AI router: many providers, one OpenAI-compatible /v1 endpoint and dashboard",
   "bin": {
     "zevai": "cli/cli.js"