llm-checker 3.5.7 → 3.5.8

package/bin/enhanced_cli.js

@@ -5059,10 +5059,16 @@ program
             console.log(`  Tier: ${chalk.cyan(detector.getHardwareTier().replace('_', ' ').toUpperCase())}`);
             console.log(`  Max model size: ${chalk.green(detector.getMaxModelSize() + 'GB')}`);
             console.log(`  Best backend: ${chalk.cyan(hardware.summary.bestBackend)}`);
+            if (hardware.summary.runtimeBackend && hardware.summary.runtimeBackend !== hardware.summary.bestBackend) {
+                console.log(`  Runtime assist: ${chalk.green(hardware.summary.runtimeBackendName || hardware.summary.runtimeBackend)}`);
+            }
             console.log(`  Dedicated GPUs: ${chalk.green(formatGpuInventoryList(hardware.summary.dedicatedGpuModels))}`);
             console.log(`  Integrated GPUs: ${chalk.hex('#FFA500')(formatGpuInventoryList(hardware.summary.integratedGpuModels))}`);
             if (hardware.summary.hasIntegratedGPU && hardware.summary.bestBackend === 'cpu') {
-                console.log(`  Assist path: ${chalk.yellow('Integrated/shared-memory GPU detected, runtime remains CPU')}`);
+                const assistMessage = hardware.summary.runtimeBackend && hardware.summary.runtimeBackend !== hardware.summary.bestBackend
+                    ? `Integrated/shared-memory GPU detected, runtime may use ${hardware.summary.runtimeBackendName || hardware.summary.runtimeBackend} acceleration`
+                    : 'Integrated/shared-memory GPU detected, runtime remains CPU';
+                console.log(`  Assist path: ${chalk.yellow(assistMessage)}`);
             }
 
             // CPU

package/bin/mcp-server.mjs

@@ -187,7 +187,7 @@ const ALLOWED_CLI_COMMANDS = new Set([
 
 const server = new McpServer({
   name: "llm-checker",
-  version: "3.5.7",
+  version: "3.5.8",
 });
 
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.7",
+  "version": "3.5.8",
   "description": "Intelligent CLI tool with AI-powered model selection that analyzes your hardware and recommends optimal LLM models for your system",
   "bin": {
     "llm-checker": "bin/cli.js",

package/src/hardware/detector.js

@@ -190,7 +190,12 @@ class HardwareDetector {
             }
             
             // Skip very generic/placeholder entries
-            if (model.includes('standard vga') || model.includes('microsoft basic')) {
+            if (
+                model.includes('standard vga') ||
+                model.includes('microsoft basic') ||
+                model.includes('remote display adapter') ||
+                model.includes('basic render driver')
+            ) {
                 return false;
             }
             

package/src/hardware/unified-detector.js

@@ -216,6 +216,9 @@ class UnifiedDetector {
         const summary = {
             bestBackend: result.primary?.type || 'cpu',
             backendName: result.primary?.name || 'CPU',
+            runtimeBackend: result.primary?.type || 'cpu',
+            runtimeBackendName: result.primary?.name || 'CPU',
+            hasRuntimeAssist: false,
             totalVRAM: 0,
             effectiveMemory: 0,
             speedCoefficient: 0,
@@ -316,6 +319,11 @@ class UnifiedDetector {
         }
         summary.hasHeterogeneousGPU = summary.hasHeterogeneousGPU || topology.isHeterogeneous;
 
+        const runtimeSelection = this.detectRuntimeAssistBackend(result, topology);
+        summary.runtimeBackend = runtimeSelection.backend;
+        summary.runtimeBackendName = runtimeSelection.name;
+        summary.hasRuntimeAssist = runtimeSelection.assisted;
+
         // Effective memory for LLM loading
         // For GPU: use VRAM; for CPU/Metal: use system RAM
         if (summary.totalVRAM > 0 && ['cuda', 'rocm', 'intel'].includes(primary?.type)) {
@@ -398,6 +406,7 @@ class UnifiedDetector {
             .map((gpu) => {
                 const name = String(gpu?.name || gpu?.model || '').replace(/\s+/g, ' ').trim();
                 if (!name) return null;
+                if (this.isRemoteDisplayModel(name)) return null;
 
                 let type = gpu?.type;
                 if (type !== 'integrated' && type !== 'dedicated') {
@@ -417,6 +426,61 @@ class UnifiedDetector {
             .filter(Boolean);
     }
 
+    isRemoteDisplayModel(model) {
+        const lower = String(model || '').toLowerCase();
+        if (!lower) return false;
+
+        return (
+            lower.includes('microsoft remote display adapter') ||
+            lower.includes('remote display adapter') ||
+            lower.includes('basic render driver')
+        );
+    }
+
+    inferGpuVendor(name) {
+        const lower = String(name || '').toLowerCase();
+        if (!lower) return 'unknown';
+        if (lower.includes('nvidia') || lower.includes('geforce') || lower.includes('rtx') || lower.includes('gtx')) return 'nvidia';
+        if (lower.includes('amd') || lower.includes('ati') || lower.includes('radeon')) return 'amd';
+        if (lower.includes('intel') || lower.includes('iris') || lower.includes('uhd') || lower.includes('arc')) return 'intel';
+        if (lower.includes('apple')) return 'apple';
+        return 'unknown';
+    }
+
+    detectRuntimeAssistBackend(result, topology = {}) {
+        const primaryType = result?.primary?.type || 'cpu';
+        const primaryName = result?.primary?.name || 'CPU';
+
+        if (primaryType !== 'cpu') {
+            return {
+                backend: primaryType,
+                name: primaryName,
+                assisted: false
+            };
+        }
+
+        const platform = result?.platform || result?.os?.platform || normalizePlatform();
+        const integratedModels = Array.isArray(topology.integratedModels) ? topology.integratedModels : [];
+        const integratedVendors = integratedModels.map((gpu) => this.inferGpuVendor(gpu.name));
+
+        const hasWindowsIntegratedGpu = platform === 'win32' && integratedModels.length > 0;
+        const hasKnownIntegratedVendor = integratedVendors.some((vendor) => ['amd', 'intel', 'nvidia'].includes(vendor));
+
+        if (hasWindowsIntegratedGpu && hasKnownIntegratedVendor) {
+            return {
+                backend: 'vulkan',
+                name: 'Vulkan',
+                assisted: true
+            };
+        }
+
+        return {
+            backend: primaryType,
+            name: primaryName,
+            assisted: false
+        };
+    }
+
     getSystemMemoryGB(memoryInfo) {
         const totalBytes = Number(memoryInfo?.total || 0);
         if (!Number.isFinite(totalBytes) || totalBytes <= 0) return 0;
@@ -496,6 +560,7 @@ class UnifiedDetector {
             .map((controller) => {
                 const name = String(controller?.model || controller?.name || '').replace(/\s+/g, ' ').trim();
                 if (!name || name.toLowerCase() === 'unknown') return null;
+                if (this.isRemoteDisplayModel(name)) return null;
 
                 const nameLower = name.toLowerCase();
                 if (nameLower.includes('microsoft basic') || nameLower.includes('standard vga')) return null;
@@ -867,16 +932,19 @@ class UnifiedDetector {
             return `${gpuDesc} (${summary.totalVRAM}GB) + ${summary.cpuModel}`;
         }
         else {
+            const runtimeAssistSuffix = summary.hasRuntimeAssist && summary.runtimeBackend !== summary.bestBackend
+                ? `${summary.runtimeBackendName || summary.runtimeBackend} assist`
+                : 'CPU backend';
             if (summary.gpuModel && summary.hasIntegratedGPU && !summary.hasDedicatedGPU) {
                 const gpuDesc = summary.gpuInventory || summary.gpuModel;
                 if (summary.integratedSharedMemory > 0) {
-                    return `${gpuDesc} (${summary.integratedSharedMemory}GB shared memory, CPU backend) + ${summary.cpuModel}`;
+                    return `${gpuDesc} (${summary.integratedSharedMemory}GB shared memory, ${runtimeAssistSuffix}) + ${summary.cpuModel}`;
                 }
-                return `${gpuDesc} (integrated/shared memory, CPU backend) + ${summary.cpuModel}`;
+                return `${gpuDesc} (integrated/shared memory, ${runtimeAssistSuffix}) + ${summary.cpuModel}`;
             }
             if (summary.gpuModel && summary.gpuCount > 0) {
                 const gpuDesc = summary.gpuInventory || summary.gpuModel;
-                return `${gpuDesc} (${summary.totalVRAM}GB VRAM detected, CPU backend) + ${summary.cpuModel}`;
+                return `${gpuDesc} (${summary.totalVRAM}GB VRAM detected, ${runtimeAssistSuffix}) + ${summary.cpuModel}`;
             }
             return `${summary.cpuModel} (${Math.round(summary.systemRAM)}GB RAM, CPU-only)`;
         }

package/src/models/intelligent-selector.js

@@ -98,7 +98,8 @@ class IntelligentSelector {
                 description: this.detector.getHardwareDescription(),
                 tier: this.detector.getHardwareTier(),
                 maxSize: this.detector.getMaxModelSize(),
-                backend: hardware.summary.bestBackend
+                backend: hardware.summary.bestBackend,
+                runtimeBackend: hardware.summary.runtimeBackend || hardware.summary.bestBackend
             },
             policy: {
                 mode: policyEngine.getMode(),
@@ -163,7 +164,7 @@ class IntelligentSelector {
 
         const context = {
             backend: summary.bestBackend || null,
-            runtimeBackend: summary.bestBackend || null,
+            runtimeBackend: summary.runtimeBackend || summary.bestBackend || null,
             ramGB: systemRAM,
             totalRamGB: systemRAM,
             hardware

package/src/ollama/client.js

@@ -4,13 +4,10 @@ class OllamaClient {
     constructor(baseURL = null) {
         // Support OLLAMA_HOST environment variable (standard Ollama configuration)
         // Also support OLLAMA_URL for backwards compatibility
-        this.baseURL = baseURL || process.env.OLLAMA_HOST || process.env.OLLAMA_URL || 'http://localhost:11434';
-
-        // Normalize URL: ensure it has protocol and remove trailing slash
-        if (!this.baseURL.startsWith('http://') && !this.baseURL.startsWith('https://')) {
-            this.baseURL = 'http://' + this.baseURL;
-        }
-        this.baseURL = this.baseURL.replace(/\/$/, '');
+        this.preferredBaseURL = this.normalizeBaseURL(
+            baseURL || process.env.OLLAMA_HOST || process.env.OLLAMA_URL || 'http://localhost:11434'
+        );
+        this.baseURL = this.preferredBaseURL;
 
         this.isAvailable = null;
         this.lastCheck = 0;
@@ -18,6 +15,53 @@ class OllamaClient {
         this._pendingCheck = null;
     }
 
+    normalizeBaseURL(baseURL) {
+        let normalized = String(baseURL || '').trim();
+        if (!normalized.startsWith('http://') && !normalized.startsWith('https://')) {
+            normalized = 'http://' + normalized;
+        }
+        return normalized.replace(/\/$/, '');
+    }
+
+    buildCandidateBaseURLs(baseURL = this.preferredBaseURL) {
+        const normalized = this.normalizeBaseURL(baseURL);
+        const candidates = [normalized];
+
+        try {
+            const parsed = new URL(normalized);
+            if (parsed.hostname === 'localhost') {
+                const ipv4 = new URL(parsed.toString());
+                ipv4.hostname = '127.0.0.1';
+                candidates.push(ipv4.toString().replace(/\/$/, ''));
+
+                const ipv6 = new URL(parsed.toString());
+                ipv6.hostname = '::1';
+                candidates.push(ipv6.toString().replace(/\/$/, ''));
+            }
+        } catch (error) {
+            // Keep the preferred URL only if parsing fails.
+        }
+
+        return [...new Set(candidates)];
+    }
+
+    applyResolvedBaseURL(baseURL) {
+        this.baseURL = this.normalizeBaseURL(baseURL);
+        return this.baseURL;
+    }
+
+    isRetryableAvailabilityError(error) {
+        const message = String(error?.message || '').toLowerCase();
+        return (
+            message.includes('econnrefused') ||
+            message.includes('fetch failed') ||
+            message.includes('network') ||
+            message.includes('socket') ||
+            message.includes('connect') ||
+            error?.name === 'AbortError'
+        );
+    }
+
     async checkOllamaAvailability() {
 
         if (this.isAvailable !== null && Date.now() - this.lastCheck < this.cacheTimeout) {
@@ -38,50 +82,79 @@ class OllamaClient {
     }
 
     async _doAvailabilityCheck() {
+        const candidateURLs = this.buildCandidateBaseURLs();
+        const attemptedURLs = [];
+        let lastError = null;
 
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 5000);
-            
-            const response = await fetch(`${this.baseURL}/api/version`, {
-                signal: controller.signal,
-                headers: { 'Content-Type': 'application/json' }
-            });
-            
-            clearTimeout(timeoutId);
+        for (let index = 0; index < candidateURLs.length; index += 1) {
+            const candidateBaseURL = candidateURLs[index];
+            attemptedURLs.push(candidateBaseURL);
+
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+                const response = await fetch(`${candidateBaseURL}/api/version`, {
+                    signal: controller.signal,
+                    headers: { 'Content-Type': 'application/json' }
+                });
+
+                clearTimeout(timeoutId);
+
+                if (!response.ok) {
+                    this.isAvailable = {
+                        available: false,
+                        error: 'Ollama not responding properly',
+                        attemptedURL: candidateBaseURL,
+                        attemptedURLs
+                    };
+                    this.lastCheck = Date.now();
+                    return this.isAvailable;
+                }
 
-            if (response.ok) {
                 const data = await response.json();
-                this.isAvailable = { available: true, version: data.version || 'unknown' };
+                this.applyResolvedBaseURL(candidateBaseURL);
+                this.isAvailable = {
+                    available: true,
+                    version: data.version || 'unknown',
+                    attemptedURL: candidateBaseURL,
+                    attemptedURLs
+                };
                 this.lastCheck = Date.now();
                 return this.isAvailable;
+            } catch (error) {
+                lastError = error;
+                if (!this.isRetryableAvailabilityError(error) || index === candidateURLs.length - 1) {
+                    break;
+                }
             }
+        }
 
-            this.isAvailable = { available: false, error: 'Ollama not responding properly' };
-            this.lastCheck = Date.now();
-            return this.isAvailable;
-        } catch (error) {
+        if (lastError) {
             let errorMessage;
             let hint = '';
+            const errorText = String(lastError.message || '');
+            const activeURL = attemptedURLs[attemptedURLs.length - 1] || this.preferredBaseURL;
 
-            if (error.message.includes('ECONNREFUSED')) {
-                errorMessage = `Ollama not running at ${this.baseURL}`;
+            if (errorText.includes('ECONNREFUSED')) {
+                errorMessage = `Ollama not running at ${activeURL}`;
                 hint = 'Make sure Ollama is running. Try: ollama serve';
-            } else if (error.message.includes('timeout') || error.name === 'AbortError') {
-                errorMessage = `Ollama connection timeout at ${this.baseURL}`;
+            } else if (errorText.includes('timeout') || lastError.name === 'AbortError') {
+                errorMessage = `Ollama connection timeout at ${activeURL}`;
                 hint = 'The server is not responding. Check if Ollama is running and accessible.';
-            } else if (error.message.includes('ENOTFOUND')) {
-                errorMessage = `Cannot resolve host: ${this.baseURL}`;
+            } else if (errorText.includes('ENOTFOUND')) {
+                errorMessage = `Cannot resolve host: ${activeURL}`;
                 hint = 'Check your OLLAMA_HOST environment variable or network configuration.';
             } else {
-                errorMessage = error.message;
+                errorMessage = errorText || 'Unknown Ollama availability error';
             }
 
             this.isAvailable = {
                 available: false,
                 error: errorMessage,
-                hint: hint,
-                attemptedURL: this.baseURL
+                hint,
+                attemptedURL: activeURL,
+                attemptedURLs
             };
             this.lastCheck = Date.now();
             return this.isAvailable;