llm-checker 3.2.4 → 3.2.6

package/README.md

@@ -93,14 +93,19 @@ npm install sql.js
 
 LLM Checker is published in all primary channels:
 
-- npm (latest): [`llm-checker@3.2.4`](https://www.npmjs.com/package/llm-checker)
-- GitHub Release: [`v3.2.4`](https://github.com/Pavelevich/llm-checker/releases/tag/v3.2.4)
+- npm (latest): [`llm-checker@latest`](https://www.npmjs.com/package/llm-checker)
+- GitHub Releases: [Release history](https://github.com/Pavelevich/llm-checker/releases)
 - GitHub Packages: [`@pavelevich/llm-checker`](https://github.com/users/Pavelevich/packages/npm/package/llm-checker)
 
-### v3.2.4 Highlights
+### v3.2.6 Highlights
 
-- Fixed `recommend` hardware-profile handling so discrete VRAM limits are honored consistently.
-- Added deterministic selector regression coverage for 24GB VRAM fit behavior.
+- Recommendation engine now enforces feasible 30B-class coverage on high-capacity discrete multi-GPU setups (for non-speed objectives).
+- Heterogeneous GPU inventories are preserved in output summaries and downstream recommendation inputs.
+- Added and validated fallback mappings/paths for:
+  - AMD Radeon AI PRO R9700 (PCI ID `7551`)
+  - NVIDIA GTX 1070 Ti (device `1b82`)
+  - Linux RX 7900 XTX detection via non-ROCm fallbacks (`lspci`/`sysfs`)
+- Expanded deterministic and hardware regression coverage for multi-GPU and unified-memory edge cases.
 
 ### Optional: Install from GitHub Packages
 
@@ -110,7 +115,7 @@ echo "@pavelevich:registry=https://npm.pkg.github.com" >> ~/.npmrc
 echo "//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}" >> ~/.npmrc
 
 # 2) Install
-npm install -g @pavelevich/llm-checker@3.2.4
+npm install -g @pavelevich/llm-checker@latest
 ```
 
 ---
@@ -356,6 +361,16 @@ Metal:
 llm-checker recommend
 ```
 
+Use optimization profiles to steer ranking by intent:
+
+```bash
+llm-checker recommend --optimize balanced
+llm-checker recommend --optimize speed
+llm-checker recommend --optimize quality
+llm-checker recommend --optimize context
+llm-checker recommend --optimize coding
+```
+
 ```
 INTELLIGENT RECOMMENDATIONS BY CATEGORY
 Hardware Tier: HIGH | Models Analyzed: 205
@@ -465,6 +480,48 @@ Memory requirements are calculated using calibrated bytes-per-parameter values:
 
 The selector automatically picks the best quantization that fits your available memory.
 
+For MoE models, deterministic memory estimation supports explicit sparse metadata when present:
+
+- `total_params_b`
+- `active_params_b`
+- `expert_count`
+- `experts_active_per_token`
+
+Normalized recommendation variants expose both snake_case and camelCase metadata aliases
+(for example: `total_params_b` + `totalParamsB`) when available.
+
+MoE parameter path selection is deterministic and uses this fallback order:
+
+1. `active_params_b` (assumption source: `moe_active_metadata`)
+2. `total_params_b * (experts_active_per_token / expert_count)` (assumption source: `moe_derived_expert_ratio`)
+3. `total_params_b` (assumption source: `moe_fallback_total_params`)
+4. Model `paramsB` fallback (assumption source: `moe_fallback_model_params`)
+
+Dense models continue to use the dense parameter path (`dense_params`) unchanged.
+
+When `active_params_b` (or a derived active-ratio path) is available, inference memory
+uses the sparse-active parameter estimate even if artifact size metadata is present.
+
+### Runtime-Aware MoE Speed Estimation
+
+MoE speed estimates now include runtime-specific overhead assumptions (routing, communication, offload), instead of using a single fixed MoE boost.
+
+- Canonical helper: `src/models/moe-assumptions.js`
+- Applied in both:
+  - `src/models/deterministic-selector.js`
+  - `src/models/scoring-engine.js`
+
+Current runtime profiles:
+
+| Runtime | Routing | Communication | Offload | Max Effective Gain |
+|:--------|:-------:|:-------------:|:-------:|:------------------:|
+| `ollama` | 18% | 13% | 8% | 2.35x |
+| `vllm` | 12% | 8% | 4% | 2.65x |
+| `mlx` | 16% | 10% | 5% | 2.45x |
+| `llama.cpp` | 20% | 14% | 9% | 2.30x |
+
+Recommendation outputs now expose these assumptions through runtime metadata and MoE speed diagnostics.
+
 ---
 
 ## Supported Hardware

package/bin/enhanced_cli.js

@@ -1027,11 +1027,13 @@ function displayIntelligentRecommendations(intelligentData) {
 
     const { summary, recommendations } = intelligentData;
     const tier = summary.hardware_tier.replace('_', ' ').toUpperCase();
+    const optimizeProfile = (summary.optimize_for || intelligentData.optimizeFor || 'balanced').toUpperCase();
     const tierColor = tier.includes('HIGH') ? chalk.green : tier.includes('MEDIUM') ? chalk.yellow : chalk.red;
 
     console.log('\n' + chalk.bgRed.white.bold(' INTELLIGENT RECOMMENDATIONS BY CATEGORY '));
     console.log(chalk.red('╭' + '─'.repeat(65)));
     console.log(chalk.red('│') + ` Hardware Tier: ${tierColor.bold(tier)} | Models Analyzed: ${chalk.cyan.bold(intelligentData.totalModelsAnalyzed)}`);
+    console.log(chalk.red('│') + ` Optimization: ${chalk.magenta.bold(optimizeProfile)}`);
     console.log(chalk.red('│'));
 
     // Mostrar mejor modelo general
@@ -1040,6 +1042,7 @@ function displayIntelligentRecommendations(intelligentData) {
         console.log(chalk.red('│') + ` ${chalk.bold.yellow('BEST OVERALL:')} ${chalk.green.bold(best.name)}`);
         console.log(chalk.red('│') + `    Command: ${chalk.cyan.bold(best.command)}`);
         console.log(chalk.red('│') + `    Score: ${chalk.yellow.bold(best.score)}/100 | Category: ${chalk.magenta(best.category)}`);
+        console.log(chalk.red('│') + `    Quantization: ${chalk.white.bold(best.quantization || 'Q4_K_M')}`);
         console.log(chalk.red('│'));
     }
 
@@ -1062,6 +1065,7 @@ function displayIntelligentRecommendations(intelligentData) {
         console.log(chalk.red('│') + ` ${chalk.bold.white(categoryName)} (${icon}):`);
         console.log(chalk.red('│') + `    ${chalk.green(model.name)} (${model.size})`);
         console.log(chalk.red('│') + `    Score: ${scoreColor.bold(model.score)}/100 | Pulls: ${chalk.gray(model.pulls?.toLocaleString() || 'N/A')}`);
+        console.log(chalk.red('│') + `    Quantization: ${chalk.white.bold(model.quantization || 'Q4_K_M')}`);
         console.log(chalk.red('│') + `    Command: ${chalk.cyan.bold(model.command)}`);
         console.log(chalk.red('│'));
     });
@@ -2303,6 +2307,7 @@ auditCommand
     .option('--out-dir <path>', 'Output directory when --out is omitted', 'audit-reports')
     .option('-u, --use-case <case>', 'Use case when --command check is selected', 'general')
     .option('-c, --category <category>', 'Category hint when --command recommend is selected')
+    .option('--optimize <profile>', 'Optimization profile for recommend mode (balanced|speed|quality|context|coding)', 'balanced')
     .option('--runtime <runtime>', `Runtime for check mode (${SUPPORTED_RUNTIMES.join('|')})`, 'ollama')
     .option('--include-cloud', 'Include cloud models in check-mode analysis')
     .option('--max-size <size>', 'Maximum model size for check mode (e.g., "24B" or "12GB")')
@@ -2356,7 +2361,9 @@ auditCommand
                 runtimeBackend = selectedRuntime;
                 policyCandidates = collectCandidatesFromAnalysis(analysisResult);
             } else {
-                recommendationResult = await checker.generateIntelligentRecommendations(hardware);
+                recommendationResult = await checker.generateIntelligentRecommendations(hardware, {
+                    optimizeFor: options.optimize
+                });
                 if (!recommendationResult) {
                     throw new Error('Unable to generate recommendation data for policy audit export.');
                 }
@@ -2390,6 +2397,7 @@ auditCommand
                     runtime: runtimeBackend,
                     use_case: selectedCommand === 'check' ? normalizeUseCaseInput(options.useCase) : null,
                     category: selectedCommand === 'recommend' ? options.category || null : null,
+                    optimize: selectedCommand === 'recommend' ? options.optimize || 'balanced' : null,
                     include_cloud: Boolean(options.includeCloud)
                 },
                 hardware
@@ -2798,6 +2806,7 @@ program
     .command('recommend')
     .description('Get intelligent model recommendations for your hardware')
     .option('-c, --category <category>', 'Get recommendations for specific category (coding, talking, reading, etc.)')
+    .option('--optimize <profile>', 'Optimization profile (balanced|speed|quality|context|coding)', 'balanced')
     .option('--no-verbose', 'Disable step-by-step progress display')
     .option('--policy <file>', 'Evaluate recommendations against a policy file')
     .addHelpText(
@@ -2821,7 +2830,9 @@ Enterprise policy examples:
             }
 
             const hardware = await checker.getSystemInfo();
-            const intelligentRecommendations = await checker.generateIntelligentRecommendations(hardware);
+            const intelligentRecommendations = await checker.generateIntelligentRecommendations(hardware, {
+                optimizeFor: options.optimize
+            });
 
             if (!intelligentRecommendations) {
                 console.error(chalk.red('\nFailed to generate recommendations'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.2.4",
+  "version": "3.2.6",
   "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",
@@ -10,9 +10,9 @@
   "main": "src/index.js",
   "scripts": {
     "test": "node tests/run-all-tests.js",
-    "test:gpu": "node tests/gpu-detection/multi-gpu.test.js",
-    "test:platform": "node tests/platform-tests/cross-platform.test.js",
-    "test:ui": "node tests/ui-tests/interface.test.js",
+    "test:gpu": "node tests/amd-gpu-detection.test.js",
+    "test:platform": "node tests/hardware-simulation-tests.js",
+    "test:ui": "node tests/ui-cli-smoke.test.js",
     "test:runtime": "node tests/runtime-specdec-tests.js",
     "test:deterministic-pool": "node tests/deterministic-model-pool-check.js",
     "test:policy": "node tests/policy-commands.test.js",

package/src/hardware/backends/rocm-detector.js

@@ -18,6 +18,8 @@ class ROCmDetector {
 
     // AMD PCI device IDs for model name resolution
     static AMD_DEVICE_IDS = {
+        // RDNA 4 / Radeon AI PRO
+        '7551': { name: 'AMD Radeon AI PRO R9700', vram: 32 },
         // RDNA 3 (RX 7000 series)
         '744c': { name: 'AMD Radeon RX 7900 XTX', vram: 24 },
         '7448': { name: 'AMD Radeon RX 7900 XT', vram: 20 },
@@ -546,8 +548,17 @@ class ROCmDetector {
             gfxVersion: null
         };
 
+        // RDNA 4 / Radeon AI PRO
+        if (nameLower.includes('r9700') || nameLower.includes('ai pro') ||
+            nameLower.includes('gfx1200') || nameLower.includes('gfx1201')) {
+            capabilities.bf16 = true;
+            capabilities.matrixCores = true;
+            capabilities.infinityCache = true;
+            capabilities.architecture = 'RDNA 4';
+            capabilities.gfxVersion = 'gfx1200';
+        }
         // RDNA 3 (RX 7000 series)
-        if (nameLower.includes('7900') || nameLower.includes('7800') ||
+        else if (nameLower.includes('7900') || nameLower.includes('7800') ||
             nameLower.includes('7700') || nameLower.includes('7600') ||
             nameLower.includes('gfx1100') || nameLower.includes('gfx1101') ||
             nameLower.includes('gfx1102')) {
@@ -598,6 +609,9 @@ class ROCmDetector {
     estimateVRAMFromModel(name) {
         const nameLower = (name || '').toLowerCase();
 
+        // RDNA 4 / Radeon AI PRO
+        if (nameLower.includes('r9700') || nameLower.includes('ai pro r9700')) return 32;
+
         // RX 7000 series
         if (nameLower.includes('7900 xtx')) return 24;
         if (nameLower.includes('7900 xt')) return 20;
@@ -634,6 +648,7 @@ class ROCmDetector {
     estimateVRAMFromGfxName(name) {
         const nameLower = (name || '').toLowerCase();
 
+        if (nameLower.includes('gfx1200') || nameLower.includes('gfx1201')) return 32; // Radeon AI PRO R9700
         if (nameLower.includes('gfx1100')) return 24;  // RX 7900 XTX
         if (nameLower.includes('gfx1101')) return 16;  // RX 7800
         if (nameLower.includes('gfx1102')) return 8;   // RX 7600
@@ -654,6 +669,10 @@ class ROCmDetector {
 
         // Speed coefficients (tokens/sec per B params at Q4)
         const speedMap = {
+            // RDNA 4 / Radeon AI PRO
+            'r9700': 230,
+            'ai pro r9700': 230,
+
             // RX 7000 series (RDNA 3)
             '7900 xtx': 200,
             '7900 xt': 180,

package/src/hardware/detector.js

@@ -86,15 +86,40 @@ class HardwareDetector {
     processGPUInfo(graphics) {
         const controllers = graphics.controllers || [];
         const displays = graphics.displays || [];
+
+        // Enrich weak/placeholder controller entries with device-id fallback.
+        const normalizedControllers = controllers.map((gpu) => {
+            const normalized = { ...gpu };
+            const originalModel = (gpu.model || '').trim();
+            const modelLower = originalModel.toLowerCase();
+
+            const hasGenericModel = !originalModel ||
+                modelLower === 'unknown' ||
+                modelLower.includes('nvidia corporation device') ||
+                /^device\s+[0-9a-f]{4}$/i.test(originalModel);
+
+            if (hasGenericModel && gpu.deviceId) {
+                const mappedModel = this.getGPUModelFromDeviceId(gpu.deviceId);
+                if (mappedModel) {
+                    normalized.model = mappedModel;
+                }
+            }
+
+            if ((!normalized.vendor || normalized.vendor.trim() === '') && normalized.model) {
+                normalized.vendor = this.inferVendorFromGPUModel(normalized.model, '');
+            }
+
+            return normalized;
+        });
         
         // Debug logging to help diagnose GPU detection issues
         if (process.env.DEBUG_GPU) {
-            console.log('GPU Detection Debug:', JSON.stringify(controllers, null, 2));
+            console.log('GPU Detection Debug:', JSON.stringify(normalizedControllers, null, 2));
         }
 
 
         // Filter out invalid/virtualized GPUs first
-        const validGPUs = controllers.filter(gpu => {
+        const validGPUs = normalizedControllers.filter(gpu => {
             const model = (gpu.model || '').toLowerCase();
             const vendor = (gpu.vendor || '').toLowerCase();
             const hasKnownModelSignature = this.looksLikeRealGPUModel(model);
@@ -199,7 +224,7 @@ class HardwareDetector {
             driverVersion: primaryGPU.driverVersion || 'Unknown',
             gpuCount: gpuCount > 0 ? gpuCount : (dedicatedGPUs.length > 0 ? dedicatedGPUs.length : 1),
             isMultiGPU: gpuCount > 1,
-            all: controllers.map(gpu => ({
+            all: normalizedControllers.map(gpu => ({
                 model: gpu.model,
                 vram: this.normalizeVRAM(gpu.vram || 0),
                 vendor: gpu.vendor || this.inferVendorFromGPUModel(gpu.model, 'Unknown')
@@ -230,7 +255,7 @@ class HardwareDetector {
             const perGPUVRAM = backendGPUs[0]?.memory?.total
                 || (gpuCount > 0 && totalVRAM > 0 ? Math.round(totalVRAM / gpuCount) : 0);
 
-            const modelFromUnified = summary.gpuModel || systemInfo.gpu.model;
+            const modelFromUnified = summary.gpuInventory || summary.gpuModel || systemInfo.gpu.model;
             const vendor = this.inferVendorFromGPUModel(modelFromUnified, systemInfo.gpu.vendor);
 
             systemInfo.gpu = {
@@ -242,6 +267,7 @@ class HardwareDetector {
                 dedicated: primaryType !== 'metal',
                 gpuCount,
                 isMultiGPU: Boolean(summary.isMultiGPU || gpuCount > 1),
+                gpuInventory: summary.gpuInventory || null,
                 backend: primaryType,
                 driverVersion: backendInfo.driver || systemInfo.gpu.driverVersion
             };
@@ -315,10 +341,14 @@ class HardwareDetector {
     getGPUModelFromDeviceId(deviceId) {
         if (!deviceId) return null;
         
-        // Normalize device ID (remove 0x prefix if present and convert to lowercase)
-        const normalizedId = deviceId.toLowerCase().replace('0x', '');
+        // Normalize device ID (handle "0x1B82", "10de:1b82", and raw variants)
+        let normalizedId = deviceId.toLowerCase().replace('0x', '');
+        const trailingHexMatch = normalizedId.match(/([0-9a-f]{4})$/);
+        if (trailingHexMatch) {
+            normalizedId = trailingHexMatch[1];
+        }
         
-        // NVIDIA RTX 50 series device IDs
+        // Known PCI device-id mappings (subset, focused on common LLM hardware)
         const deviceIdMap = {
             '2d04': 'NVIDIA GeForce RTX 5060 Ti',
             '2d05': 'NVIDIA GeForce RTX 5060',
@@ -327,7 +357,7 @@ class HardwareDetector {
             '2d08': 'NVIDIA GeForce RTX 5080',
             '2d09': 'NVIDIA GeForce RTX 5090',
             
-            // NVIDIA RTX 40 series device IDs
+            // NVIDIA RTX 40 series
             '2684': 'NVIDIA GeForce RTX 4090',
             '2685': 'NVIDIA GeForce RTX 4080',
             '2786': 'NVIDIA GeForce RTX 4070 Ti',
@@ -335,12 +365,32 @@ class HardwareDetector {
             '27a0': 'NVIDIA GeForce RTX 4060 Ti',
             '27a1': 'NVIDIA GeForce RTX 4060',
             
-            // NVIDIA RTX 30 series device IDs
+            // NVIDIA RTX 30 series
             '2204': 'NVIDIA GeForce RTX 3090',
             '2206': 'NVIDIA GeForce RTX 3080',
             '2484': 'NVIDIA GeForce RTX 3070',
             '2487': 'NVIDIA GeForce RTX 3060 Ti',
-            '2504': 'NVIDIA GeForce RTX 3060'
+            '2504': 'NVIDIA GeForce RTX 3060',
+
+            // NVIDIA Pascal (Issue #35)
+            '1b82': 'NVIDIA GeForce GTX 1070 Ti',
+            '1b81': 'NVIDIA GeForce GTX 1070',
+            '1b80': 'NVIDIA GeForce GTX 1080',
+
+            // AMD RDNA 3 / RDNA 2
+            '744c': 'AMD Radeon RX 7900 XTX',
+            '7448': 'AMD Radeon RX 7900 XT',
+            '7460': 'AMD Radeon RX 7900 GRE',
+            '7480': 'AMD Radeon RX 7800 XT',
+            '7481': 'AMD Radeon RX 7700 XT',
+            '7483': 'AMD Radeon RX 7600',
+            '7484': 'AMD Radeon RX 7600 XT',
+            '73a3': 'AMD Radeon RX 6800 XT',
+            '73a2': 'AMD Radeon RX 6800',
+            '73df': 'AMD Radeon RX 6700 XT',
+
+            // AMD Radeon AI PRO
+            '7551': 'AMD Radeon AI PRO R9700'
         };
         
         return deviceIdMap[normalizedId] || null;
@@ -383,6 +433,13 @@ class HardwareDetector {
         if (modelLower.includes('rx 7800')) return 16;
         if (modelLower.includes('rx 7700')) return 12;
         if (modelLower.includes('rx 7600')) return 8;
+        if (modelLower.includes('r9700') || modelLower.includes('ai pro r9700')) return 32;
+
+        // NVIDIA GTX Pascal
+        if (modelLower.includes('gtx 1080 ti')) return 11;
+        if (modelLower.includes('gtx 1080')) return 8;
+        if (modelLower.includes('gtx 1070 ti')) return 8;
+        if (modelLower.includes('gtx 1070')) return 8;
         
         // Generic estimates
         if (modelLower.includes('rtx')) return 8; // Default for RTX
@@ -462,9 +519,13 @@ class HardwareDetector {
         else if (model.includes('rtx 4070')) score += 20;
         else if (model.includes('rtx 30')) score += 18;
         else if (model.includes('rtx 20')) score += 15;
+        else if (model.includes('gtx 1080')) score += 14;
+        else if (model.includes('gtx 1070 ti')) score += 13;
+        else if (model.includes('gtx 1070')) score += 12;
         else if (model.includes('gtx 16')) score += 12;
         else if (model.includes('tesla p100') || model.includes('p100')) score += 14;
         else if (model.includes('apple m')) score += 15;
+        else if (model.includes('r9700') || model.includes('ai pro r9700')) score += 23;
 
         return Math.min(Math.round(score), 100);
     }
@@ -563,6 +624,9 @@ class HardwareDetector {
         if (modelLower.includes('rtx 3090')) return 85;
         if (modelLower.includes('rtx 30')) return 80;
         if (modelLower.includes('rtx 20')) return 70;
+        if (modelLower.includes('gtx 1080')) return 58;
+        if (modelLower.includes('gtx 1070 ti')) return 56;
+        if (modelLower.includes('gtx 1070')) return 54;
         if (modelLower.includes('gtx 16')) return 60;
         if (modelLower.includes('gtx 10')) return 50;
         
@@ -579,6 +643,7 @@ class HardwareDetector {
         if (modelLower.includes('rx 7700')) return 75;
         if (modelLower.includes('rx 6900')) return 70;
         if (modelLower.includes('rx 6800')) return 65;
+        if (modelLower.includes('r9700') || modelLower.includes('ai pro r9700')) return 88;
         
         // Intel
         if (modelLower.includes('arc a7')) return 55;

package/src/hardware/unified-detector.js

@@ -199,6 +199,9 @@ class UnifiedDetector {
             isMultiGPU: false,
             gpuCount: 0,
             gpuModel: null,
+            gpuInventory: null,
+            gpuModels: [],
+            hasHeterogeneousGPU: false,
             cpuModel: result.cpu?.brand || 'Unknown',
             systemRAM: require('os').totalmem() / (1024 ** 3)
         };
@@ -206,18 +209,26 @@ class UnifiedDetector {
         const primary = result.primary;
 
         if (primary?.type === 'cuda' && primary.info) {
+            const inventory = this.summarizeGPUInventory(primary.info.gpus);
             summary.totalVRAM = primary.info.totalVRAM;
             summary.gpuCount = primary.info.gpus.length;
             summary.isMultiGPU = primary.info.isMultiGPU;
             summary.speedCoefficient = primary.info.speedCoefficient;
-            summary.gpuModel = primary.info.gpus[0]?.name || 'NVIDIA GPU';
+            summary.gpuModel = inventory.primaryModel || 'NVIDIA GPU';
+            summary.gpuInventory = inventory.displayName || summary.gpuModel;
+            summary.gpuModels = inventory.models;
+            summary.hasHeterogeneousGPU = inventory.isHeterogeneous;
         }
         else if (primary?.type === 'rocm' && primary.info) {
+            const inventory = this.summarizeGPUInventory(primary.info.gpus);
             summary.totalVRAM = primary.info.totalVRAM;
             summary.gpuCount = primary.info.gpus.length;
             summary.isMultiGPU = primary.info.isMultiGPU;
             summary.speedCoefficient = primary.info.speedCoefficient;
-            summary.gpuModel = primary.info.gpus[0]?.name || 'AMD GPU';
+            summary.gpuModel = inventory.primaryModel || 'AMD GPU';
+            summary.gpuInventory = inventory.displayName || summary.gpuModel;
+            summary.gpuModels = inventory.models;
+            summary.hasHeterogeneousGPU = inventory.isHeterogeneous;
         }
         else if (primary?.type === 'metal' && primary.info) {
             // Apple Silicon uses unified memory
@@ -225,12 +236,18 @@ class UnifiedDetector {
             summary.gpuCount = 1;
             summary.speedCoefficient = primary.info.speedCoefficient;
             summary.gpuModel = primary.info.chip || 'Apple Silicon';
+            summary.gpuInventory = summary.gpuModel;
+            summary.gpuModels = [{ name: summary.gpuModel, count: 1 }];
         }
         else if (primary?.type === 'intel' && primary.info) {
+            const inventory = this.summarizeGPUInventory(primary.info.gpus);
             summary.totalVRAM = primary.info.totalVRAM;
             summary.gpuCount = primary.info.gpus.filter(g => g.type === 'dedicated').length;
             summary.speedCoefficient = primary.info.speedCoefficient;
-            summary.gpuModel = primary.info.gpus[0]?.name || 'Intel GPU';
+            summary.gpuModel = inventory.primaryModel || 'Intel GPU';
+            summary.gpuInventory = inventory.displayName || summary.gpuModel;
+            summary.gpuModels = inventory.models;
+            summary.hasHeterogeneousGPU = inventory.isHeterogeneous;
         }
         else if (result.cpu) {
             summary.speedCoefficient = result.cpu.speedCoefficient;
@@ -248,6 +265,27 @@ class UnifiedDetector {
         return summary;
     }
 
+    summarizeGPUInventory(gpus = []) {
+        const counts = new Map();
+
+        for (const gpu of gpus) {
+            const name = (gpu?.name || 'Unknown GPU').replace(/\s+/g, ' ').trim();
+            counts.set(name, (counts.get(name) || 0) + 1);
+        }
+
+        const models = Array.from(counts.entries()).map(([name, count]) => ({ name, count }));
+        const displayName = models
+            .map(({ name, count }) => (count > 1 ? `${count}x ${name}` : name))
+            .join(' + ');
+
+        return {
+            primaryModel: models[0]?.name || null,
+            displayName: displayName || null,
+            models,
+            isHeterogeneous: models.length > 1
+        };
+    }
+
     /**
      * Generate hardware fingerprint for benchmarks
      */
@@ -391,22 +429,23 @@ class UnifiedDetector {
         const summary = result.summary;
 
         if (summary.bestBackend === 'cuda') {
-            const gpuDesc = summary.isMultiGPU
-                ? `${summary.gpuCount}x ${summary.gpuModel}`
-                : summary.gpuModel;
+            const gpuDesc = summary.gpuInventory || (
+                summary.isMultiGPU ? `${summary.gpuCount}x ${summary.gpuModel}` : summary.gpuModel
+            );
             return `${gpuDesc} (${summary.totalVRAM}GB VRAM) + ${summary.cpuModel}`;
         }
         else if (summary.bestBackend === 'rocm') {
-            const gpuDesc = summary.isMultiGPU
-                ? `${summary.gpuCount}x ${summary.gpuModel}`
-                : summary.gpuModel;
+            const gpuDesc = summary.gpuInventory || (
+                summary.isMultiGPU ? `${summary.gpuCount}x ${summary.gpuModel}` : summary.gpuModel
+            );
             return `${gpuDesc} (${summary.totalVRAM}GB VRAM) + ${summary.cpuModel}`;
         }
         else if (summary.bestBackend === 'metal') {
             return `${summary.gpuModel} (${summary.totalVRAM}GB Unified Memory)`;
         }
         else if (summary.bestBackend === 'intel') {
-            return `${summary.gpuModel} (${summary.totalVRAM}GB) + ${summary.cpuModel}`;
+            const gpuDesc = summary.gpuInventory || summary.gpuModel;
+            return `${gpuDesc} (${summary.totalVRAM}GB) + ${summary.cpuModel}`;
         }
         else {
             return `${summary.cpuModel} (${Math.round(summary.systemRAM)}GB RAM, CPU-only)`;

package/src/index.js

@@ -258,7 +258,10 @@ class LLMChecker {
             this.progress.step('Smart Recommendations', 'Generating personalized model suggestions...');
         }
 
-        const recommendations = await this.generateIntelligentRecommendations(hardware);
+        const recommendations = await this.generateIntelligentRecommendations(hardware, {
+            optimizeFor: options.optimizeFor || options.optimize,
+            runtime: options.runtime
+        });
         const intelligentRecommendations = recommendations;
 
         if (this.progress) {
@@ -2382,9 +2385,10 @@ class LLMChecker {
     }
 
 
-    async generateIntelligentRecommendations(hardware) {
+    async generateIntelligentRecommendations(hardware, options = {}) {
         try {
             this.logger.info('Generating intelligent recommendations...');
+            const selectedRuntime = normalizeRuntime(options.runtime || 'ollama');
             
             // Obtener todos los modelos de Ollama
             const ollamaData = await this.ollamaScraper.scrapeAllModels(false);
@@ -2396,14 +2400,25 @@ class LLMChecker {
             }
 
             // Generar recomendaciones inteligentes
-            const recommendations = await this.intelligentRecommender.getBestModelsForHardware(hardware, allModels);
-            const summary = this.intelligentRecommender.generateRecommendationSummary(recommendations, hardware);
+            const optimizeFor = options.optimizeFor || options.optimize || 'balanced';
+            const recommendations = await this.intelligentRecommender.getBestModelsForHardware(
+                hardware,
+                allModels,
+                { optimizeFor, runtime: selectedRuntime }
+            );
+            const summary = this.intelligentRecommender.generateRecommendationSummary(
+                recommendations,
+                hardware,
+                { optimizeFor }
+            );
 
             this.logger.info(`Generated recommendations for ${Object.keys(recommendations).length} categories`);
             
             return {
                 recommendations,
                 summary,
+                optimizeFor: summary.optimize_for || optimizeFor,
+                runtime: selectedRuntime,
                 totalModelsAnalyzed: allModels.length,
                 generatedAt: new Date().toISOString()
             };