nvicode 0.1.19 → 0.1.20

package/README.md

@@ -17,6 +17,7 @@ What it gives you:
 - OpenClaw support
 - NVIDIA proxy mode with pacing and local usage tracking
 - OpenRouter direct mode for compatible models
+- Dynamic NVIDIA model discovery for current Kimi, DeepSeek, GLM, and Qwen picks
 
 Supported environments:
 - macOS
@@ -116,6 +117,7 @@ nvicode launch codex "Explain this project"
 
 Behavior notes:
 - `nvicode select model` asks for provider, optional API key update, and model choice in one guided flow.
+- For NVIDIA, model selection fetches the live NVIDIA catalog and highlights one current top pick each from Kimi, DeepSeek, GLM, and Qwen before falling back to curated defaults.
 - Claude Code uses direct OpenRouter mode for OpenRouter, and proxy mode for NVIDIA.
 - Codex currently uses the local `nvicode` proxy path.
 - `nvicode usage`, `activity`, and `dashboard` are currently focused on NVIDIA proxy sessions.

package/dist/cli.js

@@ -448,11 +448,19 @@ const runDashboard = async () => {
     console.log("");
     await runActivity();
 };
-const waitForHealthyProxy = async (port) => {
+const PROXY_PROTOCOL_VERSION = 2;
+const isExpectedProxyHealth = (config, health) => health.ok === true &&
+    health.proxyProtocolVersion === PROXY_PROTOCOL_VERSION &&
+    health.provider === config.provider &&
+    health.model === getActiveModel(config) &&
+    health.port === config.proxyPort &&
+    health.thinking === config.thinking &&
+    health.maxRequestsPerMinute === config.maxRequestsPerMinute;
+const waitForHealthyProxy = async (config) => {
     for (let attempt = 0; attempt < 50; attempt += 1) {
         try {
-            const response = await fetch(`http://127.0.0.1:${port}/health`);
-            if (response.ok) {
+            const response = await fetch(`http://127.0.0.1:${config.proxyPort}/health`);
+            if (response.ok && isExpectedProxyHealth(config, await response.json())) {
                 return true;
             }
         }
@@ -463,11 +471,35 @@ const waitForHealthyProxy = async (port) => {
     }
     return false;
 };
+const stopExistingProxy = async () => {
+    const paths = getNvicodePaths();
+    const rawPid = await readIfExists(paths.pidFile);
+    const pid = Number(rawPid?.trim());
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        return;
+    }
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+        try {
+            process.kill(pid, 0);
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        catch {
+            break;
+        }
+    }
+};
 const ensureProxyRunning = async (config) => {
-    if (await waitForHealthyProxy(config.proxyPort)) {
+    if (await waitForHealthyProxy(config)) {
         return;
     }
     const paths = getNvicodePaths();
+    await stopExistingProxy();
     await fs.mkdir(paths.stateDir, { recursive: true });
     const logFd = openSync(paths.logFile, "a");
     const child = spawn(process.execPath, [__filename, "serve"], {
@@ -480,7 +512,7 @@ const ensureProxyRunning = async (config) => {
     });
     child.unref();
     await fs.writeFile(paths.pidFile, `${child.pid}\n`);
-    if (!(await waitForHealthyProxy(config.proxyPort))) {
+    if (!(await waitForHealthyProxy(config))) {
         throw new Error(`nvicode proxy failed to start. See ${paths.logFile}`);
     }
 };
@@ -536,6 +568,30 @@ const resolvePersistentClaudeCommand = async () => {
     }
     return null;
 };
+const resolveLatestClaudeManagedVersion = async () => {
+    const versionsDir = path.join(os.homedir(), ".local", "share", "claude", "versions");
+    try {
+        const entries = await fs.readdir(versionsDir);
+        const sortedEntries = entries.sort((left, right) => left.localeCompare(right, undefined, {
+            numeric: true,
+            sensitivity: "base",
+        }));
+        for (let index = sortedEntries.length - 1; index >= 0; index -= 1) {
+            const entry = sortedEntries[index];
+            if (!entry) {
+                continue;
+            }
+            const resolved = await resolveClaudeVersionEntry(path.join(versionsDir, entry));
+            if (resolved) {
+                return resolved;
+            }
+        }
+    }
+    catch {
+        // continue with other install layouts
+    }
+    return null;
+};
 const getWrapperInstallPaths = async (claudeCommandPath) => {
     const directory = path.dirname(claudeCommandPath);
     const existingNative = await findExistingClaudeNativeInDirectory(directory);
@@ -656,6 +712,10 @@ const ensurePersistentCodexRouting = async () => {
     return "installed";
 };
 const resolveClaudeBinary = async () => {
+    const latestManagedVersion = await resolveLatestClaudeManagedVersion();
+    if (latestManagedVersion) {
+        return latestManagedVersion;
+    }
     for (const name of getClaudeNativeNames()) {
         const nativeInPath = await findExecutableInPath(name);
         if (nativeInPath) {
@@ -674,27 +734,10 @@ const resolveClaudeBinary = async () => {
             path.join(os.homedir(), ".local", "bin", "claude"),
         ];
     for (const candidate of homeBinCandidates) {
-        if (await isExecutable(candidate)) {
+        if ((await isExecutable(candidate)) && !(await isManagedClaudeWrapper(candidate))) {
             return candidate;
         }
     }
-    const versionsDir = path.join(os.homedir(), ".local", "share", "claude", "versions");
-    try {
-        const entries = await fs.readdir(versionsDir);
-        const latest = entries.sort((left, right) => left.localeCompare(right, undefined, {
-            numeric: true,
-            sensitivity: "base",
-        })).at(-1);
-        if (latest) {
-            const resolved = await resolveClaudeVersionEntry(path.join(versionsDir, latest));
-            if (resolved) {
-                return resolved;
-            }
-        }
-    }
-    catch {
-        // continue
-    }
     for (const name of getClaudeCommandNames()) {
         const claudeInPath = await findExecutableInPath(name);
         if (claudeInPath && !(await isManagedClaudeWrapper(claudeInPath))) {

package/dist/config.js

@@ -7,6 +7,12 @@ const DEFAULT_PROVIDER = "nvidia";
 const DEFAULT_NVIDIA_MODEL = "moonshotai/kimi-k2.5";
 const DEFAULT_OPENROUTER_MODEL = "anthropic/claude-sonnet-4.6";
 const DEFAULT_MAX_REQUESTS_PER_MINUTE = 40;
+const NVIDIA_MODEL_ALIASES = {
+    "deepseek/deepseek-v4-pro": "deepseek-ai/deepseek-v4-flash",
+    "deepseek-ai/deepseek-v4-pro": "deepseek-ai/deepseek-v4-flash",
+    "deepseek-ai/deepseek-v3.2": "deepseek-ai/deepseek-v4-flash",
+};
+const normalizeNvidiaModel = (model) => NVIDIA_MODEL_ALIASES[model] || model;
 const getEnvNumber = (name) => {
     const raw = process.env[name];
     if (!raw) {
@@ -61,7 +67,7 @@ const withDefaults = (config) => {
     return {
         provider: config.provider === "openrouter" ? "openrouter" : DEFAULT_PROVIDER,
         nvidiaApiKey: config.nvidiaApiKey?.trim() || legacyApiKey,
-        nvidiaModel: config.nvidiaModel?.trim() || legacyModel,
+        nvidiaModel: normalizeNvidiaModel(config.nvidiaModel?.trim() || legacyModel),
         openrouterApiKey: config.openrouterApiKey?.trim() || "",
         openrouterModel: config.openrouterModel?.trim() || DEFAULT_OPENROUTER_MODEL,
         proxyPort: Number.isInteger(config.proxyPort) && config.proxyPort > 0

package/dist/models.js

@@ -15,9 +15,9 @@ export const NVIDIA_CURATED_MODELS = [
         description: "General purpose reasoning model with code capability.",
     },
     {
-        id: "deepseek-ai/deepseek-v3.2",
-        label: "DeepSeek V3.2",
-        description: "General coding and reasoning model.",
+        id: "deepseek-ai/deepseek-v4-flash",
+        label: "DeepSeek V4 Flash",
+        description: "Responsive DeepSeek V4-family model.",
     },
     {
         id: "mistralai/codestral-22b-instruct-v0.1",
@@ -30,6 +30,36 @@ export const NVIDIA_CURATED_MODELS = [
         description: "Smaller coding-focused Qwen model.",
     },
 ];
+const NVIDIA_MODEL_FAMILIES = [
+    {
+        name: "Kimi",
+        labelPrefix: "Kimi",
+        description: "Latest available Kimi model from NVIDIA.",
+        match: /^moonshotai\/kimi/i,
+        prefer: [/k2\.5/i, /thinking/i, /instruct/i],
+    },
+    {
+        name: "DeepSeek",
+        labelPrefix: "DeepSeek",
+        description: "Latest available DeepSeek model from NVIDIA.",
+        match: /^deepseek-ai\/deepseek/i,
+        prefer: [/v4-flash/i, /v4-pro/i, /v4/i, /v3\.2/i, /coder/i],
+    },
+    {
+        name: "GLM",
+        labelPrefix: "GLM",
+        description: "Latest available GLM model from NVIDIA.",
+        match: /^z-ai\/glm/i,
+        prefer: [/5\.1/i, /5/i, /4\.7/i],
+    },
+    {
+        name: "Qwen",
+        labelPrefix: "Qwen",
+        description: "Latest available Qwen coding model from NVIDIA.",
+        match: /^qwen\/qwen/i,
+        prefer: [/qwen3-coder/i, /qwen3\.5/i, /qwen3-next/i, /qwen3/i, /qwen2\.5-coder/i],
+    },
+];
 export const OPENROUTER_CURATED_MODELS = [
     {
         id: "qwen/qwen3.6-plus-preview:free",
@@ -71,14 +101,87 @@ export const fetchAvailableModelIds = async (apiKey) => {
     }
     return ids;
 };
+const formatModelNameToken = (part) => {
+    const normalized = part.toLowerCase();
+    const brandNames = {
+        deepseek: "DeepSeek",
+        glm: "GLM",
+        kimi: "Kimi",
+        qwen: "Qwen",
+    };
+    if (brandNames[normalized]) {
+        return brandNames[normalized];
+    }
+    if (/^[vk]\d/i.test(part) || /^\d+b$/i.test(part) || /^a\d+b$/i.test(part)) {
+        return part.toUpperCase();
+    }
+    return part.charAt(0).toUpperCase() + part.slice(1);
+};
+const titleCaseModelPart = (value) => value
+    .split(/[-_]/)
+    .filter(Boolean)
+    .map(formatModelNameToken)
+    .join(" ");
+const formatDynamicLabel = (family, id) => {
+    const modelName = id.split("/").at(-1) || id;
+    return `${family.labelPrefix}: ${titleCaseModelPart(modelName)}`;
+};
+const getVersionScore = (id) => {
+    const versionNumbers = [...id.matchAll(/\d+(?:\.\d+)?/g)]
+        .map((match) => Number(match[0]))
+        .filter((value) => Number.isFinite(value));
+    if (versionNumbers.length === 0) {
+        return 0;
+    }
+    return Math.max(...versionNumbers);
+};
+const scoreFamilyModel = (family, id) => {
+    let score = getVersionScore(id);
+    family.prefer.forEach((pattern, index) => {
+        if (pattern.test(id)) {
+            score += (family.prefer.length - index) * 1000;
+        }
+    });
+    if (/preview|beta|experimental/i.test(id)) {
+        score -= 10;
+    }
+    return score;
+};
+const pickFamilyModel = (family, ids) => {
+    const candidates = ids.filter((id) => family.match.test(id));
+    if (candidates.length === 0) {
+        return null;
+    }
+    const [best] = candidates.sort((left, right) => {
+        const scoreDelta = scoreFamilyModel(family, right) - scoreFamilyModel(family, left);
+        return scoreDelta || right.localeCompare(left, undefined, { numeric: true });
+    });
+    if (!best) {
+        return null;
+    }
+    return {
+        id: best,
+        label: formatDynamicLabel(family, best),
+        description: family.description,
+    };
+};
+const getDynamicNvidiaModels = (available) => {
+    const ids = [...available];
+    const picked = NVIDIA_MODEL_FAMILIES
+        .map((family) => pickFamilyModel(family, ids))
+        .filter((model) => Boolean(model));
+    const seen = new Set(picked.map((model) => model.id));
+    const fallback = NVIDIA_CURATED_MODELS.filter((model) => available.has(model.id) && !seen.has(model.id));
+    return [...picked, ...fallback];
+};
 export const getRecommendedModels = async (provider, apiKey) => {
     if (provider === "openrouter") {
         return OPENROUTER_CURATED_MODELS;
     }
     try {
         const available = await fetchAvailableModelIds(apiKey);
-        const curated = NVIDIA_CURATED_MODELS.filter((model) => available.has(model.id));
-        return curated.length > 0 ? curated : NVIDIA_CURATED_MODELS;
+        const dynamic = getDynamicNvidiaModels(available);
+        return dynamic.length > 0 ? dynamic : NVIDIA_CURATED_MODELS;
     }
     catch {
         return NVIDIA_CURATED_MODELS;

package/dist/proxy.js

@@ -6,12 +6,33 @@ const NVIDIA_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
 const OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
 const DEFAULT_RETRY_DELAY_MS = 2_000;
 const MAX_NVIDIA_RETRIES = 3;
+const UPSTREAM_TIMEOUT_MS = 60_000;
+const PROXY_PROTOCOL_VERSION = 2;
 const sleep = async (ms) => {
     if (ms <= 0) {
         return;
     }
     await new Promise((resolve) => setTimeout(resolve, ms));
 };
+const fetchWithTimeout = async (input, init) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), UPSTREAM_TIMEOUT_MS);
+    try {
+        return await fetch(input, {
+            ...init,
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        if (error.name === "AbortError") {
+            throw new Error(`Upstream API timed out after ${UPSTREAM_TIMEOUT_MS / 1000}s`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+};
 const parseRetryAfterMs = (value) => {
     if (!value) {
         return null;
@@ -415,14 +436,14 @@ const callNvidia = async (config, scheduleRequest, payload) => {
     if (toolChoice) {
         requestBody.tool_choice = toolChoice;
     }
-    if (config.thinking) {
+    if (config.provider === "nvidia") {
         requestBody.chat_template_kwargs = {
-            thinking: true,
+            thinking: config.thinking,
         };
     }
     const invoke = async () => {
         for (let attempt = 0; attempt <= MAX_NVIDIA_RETRIES; attempt += 1) {
-            const response = await fetch(NVIDIA_URL, {
+            const response = await fetchWithTimeout(NVIDIA_URL, {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${config.nvidiaApiKey}`,
@@ -654,7 +675,7 @@ const callChatCompletions = async (config, scheduleRequest, body) => {
     const apiKey = getActiveApiKey(config);
     const invoke = async () => {
         for (let attempt = 0; attempt <= MAX_NVIDIA_RETRIES; attempt += 1) {
-            const resp = await fetch(upstreamUrl, {
+            const resp = await fetchWithTimeout(upstreamUrl, {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${apiKey}`,
@@ -691,7 +712,9 @@ export const createProxyServer = (config) => {
             if (url.pathname === "/health") {
                 sendJson(response, 200, {
                     ok: true,
-                    model: config.nvidiaModel,
+                    proxyProtocolVersion: PROXY_PROTOCOL_VERSION,
+                    provider: config.provider,
+                    model: getActiveModel(config),
                     port: config.proxyPort,
                     thinking: config.thinking,
                     maxRequestsPerMinute: config.maxRequestsPerMinute,
@@ -872,6 +895,11 @@ export const createProxyServer = (config) => {
                     max_tokens: payload.max_output_tokens ?? 16_384,
                     stream: false,
                 };
+                if (config.provider === "nvidia") {
+                    chatBody.chat_template_kwargs = {
+                        thinking: config.thinking,
+                    };
+                }
                 if (typeof payload.temperature === "number") {
                     chatBody.temperature = payload.temperature;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvicode",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Route Claude Code, Codex CLI, and OpenClaw through NVIDIA or OpenRouter with one setup.",
   "author": "Dinesh Potla",
   "keywords": [