llm-checker 3.4.2 → 3.5.1

package/src/utils/token-speed-estimator.js

@@ -0,0 +1,207 @@
+function toNumber(value, fallback = 0) {
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed) {
+            const parsed = Number(trimmed);
+            if (Number.isFinite(parsed)) return parsed;
+        }
+    }
+    return fallback;
+}
+
+function normalizeModelSizeB(rawModelSizeB) {
+    const value = toNumber(rawModelSizeB, 1);
+    return Math.max(0.7, value);
+}
+
+function detectAppleSilicon(architecture, cpuModel, gpuModel) {
+    const signal = `${architecture} ${cpuModel} ${gpuModel}`.toLowerCase();
+    return (
+        signal.includes('apple silicon') ||
+        /(^|\s)m[1-4](\s|$)/.test(signal) ||
+        signal.includes('apple m1') ||
+        signal.includes('apple m2') ||
+        signal.includes('apple m3') ||
+        signal.includes('apple m4')
+    );
+}
+
+function isIntegratedGPU(gpuModel = '') {
+    return /iris.*xe|iris.*graphics|uhd.*graphics|vega.*integrated|radeon.*graphics|intel.*integrated|integrated/i.test(gpuModel);
+}
+
+function getAppleSiliconBaseline(cpuModel, gpuModel) {
+    const signal = `${cpuModel} ${gpuModel}`.toLowerCase();
+    const profiles = [
+        { pattern: /m4 ultra/, tps7b: 95 },
+        { pattern: /m4 max/, tps7b: 65 },
+        { pattern: /m4 pro/, tps7b: 43 },
+        { pattern: /m4/, tps7b: 30 },
+        { pattern: /m3 ultra/, tps7b: 88 },
+        { pattern: /m3 max/, tps7b: 58 },
+        { pattern: /m3 pro/, tps7b: 34 },
+        { pattern: /m3/, tps7b: 27 },
+        { pattern: /m2 ultra/, tps7b: 80 },
+        { pattern: /m2 max/, tps7b: 52 },
+        { pattern: /m2 pro/, tps7b: 32 },
+        { pattern: /m2/, tps7b: 24 },
+        { pattern: /m1 ultra/, tps7b: 72 },
+        { pattern: /m1 max/, tps7b: 48 },
+        { pattern: /m1 pro/, tps7b: 30 },
+        { pattern: /m1/, tps7b: 22 }
+    ];
+
+    for (const profile of profiles) {
+        if (profile.pattern.test(signal)) {
+            return profile.tps7b;
+        }
+    }
+    return 24;
+}
+
+function getDedicatedGPUBaseline(gpuModel, vramGB) {
+    const signal = (gpuModel || '').toLowerCase();
+    const profiles = [
+        { pattern: /h100/, tps7b: 170 },
+        { pattern: /a100/, tps7b: 130 },
+        { pattern: /rtx 50|rtx50|blackwell/, tps7b: 105 },
+        { pattern: /rtx 4090/, tps7b: 80 },
+        { pattern: /rtx 4080/, tps7b: 65 },
+        { pattern: /rtx 3090/, tps7b: 62 },
+        { pattern: /rtx 3080/, tps7b: 50 },
+        { pattern: /rtx 3070/, tps7b: 42 },
+        { pattern: /rtx 3060/, tps7b: 34 },
+        { pattern: /rtx 20/, tps7b: 26 },
+        { pattern: /rx 79|7900|7800/, tps7b: 52 },
+        { pattern: /rx 69|6800/, tps7b: 42 }
+    ];
+
+    for (const profile of profiles) {
+        if (profile.pattern.test(signal)) {
+            return profile.tps7b;
+        }
+    }
+
+    if (vramGB >= 24) return 60;
+    if (vramGB >= 16) return 48;
+    if (vramGB >= 12) return 40;
+    if (vramGB >= 8) return 30;
+    if (vramGB >= 4) return 18;
+    return 14;
+}
+
+function hasAVX512(cpuModel = '') {
+    const signal = cpuModel.toLowerCase();
+    return signal.includes('avx512') ||
+        (signal.includes('intel') &&
+            (signal.includes('12th') || signal.includes('13th') || signal.includes('14th')));
+}
+
+function hasAVX2(cpuModel = '') {
+    const signal = cpuModel.toLowerCase();
+    return signal.includes('avx2') || signal.includes('intel') || signal.includes('amd');
+}
+
+function getCPUBaseline(cpuModel, cores, baseSpeedGHz, integratedGpuAssist) {
+    let baseline = 4 + (cores * 0.6) + ((Math.max(1.5, baseSpeedGHz) - 2.0) * 2.5);
+
+    if (hasAVX512(cpuModel)) baseline += 3;
+    else if (hasAVX2(cpuModel)) baseline += 1.5;
+
+    if (integratedGpuAssist) baseline += 1;
+
+    const maxBaseline = integratedGpuAssist ? 22 : 18;
+    return Math.max(3, Math.min(maxBaseline, baseline));
+}
+
+function calculateSizeScale(modelSizeB) {
+    const scale = Math.pow(7 / modelSizeB, 0.72);
+    return Math.max(0.18, Math.min(2.2, scale));
+}
+
+function calculateMemoryFactor(modelSizeB, availableInferenceMemoryGB) {
+    const estimatedWorkingSetGB = (modelSizeB * 0.75) + 2;
+    const ratio = availableInferenceMemoryGB / Math.max(1, estimatedWorkingSetGB);
+
+    if (ratio >= 1.2) return 1.05;
+    if (ratio >= 1.0) return 1.0;
+    if (ratio >= 0.75) return 0.85;
+    if (ratio >= 0.6) return 0.65;
+    return 0.45;
+}
+
+function estimateTokenSpeedFromHardware(hardware = {}, options = {}) {
+    const cpuModel = String(hardware.cpu?.brand || hardware.cpu?.model || '');
+    const gpuModel = String(hardware.gpu?.model || '');
+    const architecture = String(hardware.cpu?.architecture || '');
+
+    const modelSizeB = normalizeModelSizeB(options.modelSizeB);
+    const cores = Math.max(1, toNumber(hardware.cpu?.physicalCores || hardware.cpu?.cores, 1));
+    const baseSpeedGHz = Math.max(1.5, toNumber(hardware.cpu?.speed || hardware.cpu?.speedMax, 2.4));
+
+    const memoryTotalGB = Math.max(
+        2,
+        toNumber(
+            hardware.memory?.total ||
+            hardware.memory?.totalGB ||
+            hardware.memory_gb,
+            8
+        )
+    );
+
+    const vramGB = Math.max(
+        0,
+        toNumber(
+            hardware.gpu?.vram ||
+            hardware.gpu?.vramGB ||
+            hardware.gpu?.totalVRAM ||
+            hardware.gpu?.memory?.total,
+            0
+        )
+    );
+
+    const appleSilicon = detectAppleSilicon(architecture, cpuModel, gpuModel);
+    const integrated = isIntegratedGPU(gpuModel);
+    const dedicatedGPU = vramGB > 0 && !integrated && !appleSilicon;
+
+    let baselineTPS7B;
+    let backend;
+    let availableInferenceMemoryGB;
+
+    if (appleSilicon) {
+        backend = 'metal';
+        baselineTPS7B = getAppleSiliconBaseline(cpuModel, gpuModel);
+        availableInferenceMemoryGB = memoryTotalGB * 0.82;
+    } else if (dedicatedGPU) {
+        backend = 'gpu';
+        baselineTPS7B = getDedicatedGPUBaseline(gpuModel, vramGB);
+        availableInferenceMemoryGB = vramGB + Math.min(memoryTotalGB * 0.15, 8);
+    } else {
+        backend = integrated ? 'integrated' : 'cpu';
+        baselineTPS7B = getCPUBaseline(cpuModel, cores, baseSpeedGHz, integrated);
+        availableInferenceMemoryGB = memoryTotalGB * 0.65;
+    }
+
+    const sizeScale = calculateSizeScale(modelSizeB);
+    const memoryFactor = calculateMemoryFactor(modelSizeB, availableInferenceMemoryGB);
+
+    const maxTPS = backend === 'metal' ? 140 : backend === 'gpu' ? 220 : 35;
+    const minTPS = backend === 'cpu' ? 1 : 2;
+
+    const estimated = baselineTPS7B * sizeScale * memoryFactor;
+    const tokensPerSecond = Math.max(minTPS, Math.min(maxTPS, Math.round(estimated)));
+
+    return {
+        tokensPerSecond,
+        backend,
+        baselineTPS7B: Math.round(baselineTPS7B * 10) / 10,
+        sizeScale: Math.round(sizeScale * 1000) / 1000,
+        memoryFactor: Math.round(memoryFactor * 1000) / 1000,
+        modelSizeB
+    };
+}
+
+module.exports = {
+    estimateTokenSpeedFromHardware
+};

package/src/ollama/gpu-placement-planner.js

@@ -1,496 +0,0 @@
-class OllamaGPUPlacementPlanner {
-    constructor(options = {}) {
-        this.minContext = options.minContext || 2048;
-        this.defaultReserveGB = options.defaultReserveGB || 1;
-        this.kvFactorPer4k = options.kvFactorPer4k || 0.08; // GB per 1B params at 4K context
-        this.modelOverheadGB = options.modelOverheadGB || 0.7;
-        this.spreadOverheadGB = options.spreadOverheadGB || 0.35;
-    }
-
-    toFiniteNumber(value, fallback = 0) {
-        const numeric = Number(value);
-        return Number.isFinite(numeric) ? numeric : fallback;
-    }
-
-    clamp(value, min, max) {
-        return Math.min(max, Math.max(min, value));
-    }
-
-    normalizeObjective(objective) {
-        const normalized = String(objective || 'balanced').toLowerCase();
-        if (normalized === 'latency' || normalized === 'balanced' || normalized === 'throughput') {
-            return normalized;
-        }
-        return 'balanced';
-    }
-
-    parseParamsB(model = {}) {
-        const bySize = String(model.size || '').match(/(\d+(?:\.\d+)?)\s*b/i);
-        if (bySize) {
-            return this.toFiniteNumber(bySize[1], 0);
-        }
-
-        const byName = String(model.name || '').match(/(\d+(?:\.\d+)?)\s*b\b/i);
-        if (byName) {
-            return this.toFiniteNumber(byName[1], 0);
-        }
-
-        const fileSizeGB = this.toFiniteNumber(model.fileSizeGB, 0);
-        if (fileSizeGB > 0) {
-            return fileSizeGB / 0.65;
-        }
-
-        return 7;
-    }
-
-    estimateBaseMemoryGB(model = {}) {
-        const fileSizeGB = this.toFiniteNumber(model.fileSizeGB, 0);
-        if (fileSizeGB > 0) {
-            return fileSizeGB + this.modelOverheadGB;
-        }
-
-        const paramsB = this.parseParamsB(model);
-        return paramsB * 0.65 + this.modelOverheadGB;
-    }
-
-    estimateKVCacheGB(paramsB, contextTokens) {
-        const ctx = this.toFiniteNumber(contextTokens, this.minContext);
-        return paramsB * this.kvFactorPer4k * (ctx / 4096);
-    }
-
-    normalizeQuantization(rawQuant) {
-        const quant = String(rawQuant || 'Q4_K_M').toUpperCase();
-        if (quant.includes('FP16') || quant.includes('F16')) return 'FP16';
-        if (quant.includes('Q8')) return 'Q8_0';
-        if (quant.includes('Q6')) return 'Q6_K';
-        if (quant.includes('Q5')) return 'Q5_K_M';
-        if (quant.includes('IQ4')) return 'IQ4_XS';
-        if (quant.includes('Q4')) return 'Q4_K_M';
-        if (quant.includes('IQ3')) return 'IQ3_XXS';
-        if (quant.includes('Q3')) return 'Q3_K_M';
-        if (quant.includes('Q2')) return 'Q2_K';
-        return 'Q4_K_M';
-    }
-
-    quantizationMultiplier(quantization) {
-        const table = {
-            FP16: 1.0,
-            Q8_0: 1.5,
-            Q6_K: 1.8,
-            Q5_K_M: 2.0,
-            Q4_K_M: 2.4,
-            IQ4_XS: 2.5,
-            Q3_K_M: 2.9,
-            IQ3_XXS: 3.1,
-            Q2_K: 3.4
-        };
-        return table[this.normalizeQuantization(quantization)] || 2.0;
-    }
-
-    estimateTokensPerSecond(gpu, model, contextTokens) {
-        const paramsB = Math.max(0.5, this.toFiniteNumber(model.paramsB, 7));
-        const speedCoefficient = Math.max(1, this.toFiniteNumber(gpu.speedCoefficient, 60));
-        const quantMult = this.quantizationMultiplier(model.quantization);
-
-        // Larger contexts reduce generation speed in practice.
-        const contextScale = Math.max(0.55, Math.pow(4096 / Math.max(4096, contextTokens), 0.12));
-        return Math.max(1, Math.round((speedCoefficient / paramsB) * quantMult * contextScale));
-    }
-
-    normalizeModels(models = []) {
-        const normalized = models
-            .filter((model) => model && model.name)
-            .map((model) => {
-                const paramsB = this.parseParamsB(model);
-                const baseMemoryGB = this.estimateBaseMemoryGB(model);
-                const fileSizeGB = this.toFiniteNumber(model.fileSizeGB, Math.max(0, baseMemoryGB - this.modelOverheadGB));
-                const quantization = model.quantization || model.details?.quantization_level || 'Q4_K_M';
-                return {
-                    name: model.name,
-                    size: model.size || `${Math.round(paramsB)}B`,
-                    fileSizeGB: Math.round(fileSizeGB * 10) / 10,
-                    paramsB: Math.round(paramsB * 10) / 10,
-                    baseMemoryGB: Math.round(baseMemoryGB * 100) / 100,
-                    quantization
-                };
-            });
-
-        normalized.sort((a, b) => b.baseMemoryGB - a.baseMemoryGB);
-        return normalized;
-    }
-
-    resolveDeviceEnvVar(backend) {
-        if (backend === 'cuda') return 'CUDA_VISIBLE_DEVICES';
-        if (backend === 'rocm') return 'HIP_VISIBLE_DEVICES';
-        return null;
-    }
-
-    resolveHardware(hardware = {}, reserveGB = null) {
-        const summary = hardware.summary || {};
-        const primary = hardware.primary || {};
-        const backend = summary.bestBackend || primary.type || 'cpu';
-        const backendName = summary.backendName || primary.name || 'CPU';
-
-        const backendInfo = primary.info || hardware.backends?.[backend]?.info || {};
-        const rawGpus = Array.isArray(backendInfo.gpus) ? backendInfo.gpus : [];
-
-        let gpus = rawGpus.map((gpu, index) => ({
-            index: this.toFiniteNumber(gpu.index, index),
-            name: String(gpu.name || `GPU ${index}`),
-            memoryGB: Math.max(1, this.toFiniteNumber(gpu.memory?.total, 0)),
-            speedCoefficient: Math.max(1, this.toFiniteNumber(gpu.speedCoefficient, summary.speedCoefficient || 60))
-        }));
-
-        if (!gpus.length && this.toFiniteNumber(summary.totalVRAM, 0) > 0) {
-            gpus = [{
-                index: 0,
-                name: summary.gpuModel || 'GPU 0',
-                memoryGB: Math.max(1, this.toFiniteNumber(summary.totalVRAM, 0)),
-                speedCoefficient: Math.max(1, this.toFiniteNumber(summary.speedCoefficient, 80))
-            }];
-        }
-
-        if (!gpus.length) {
-            gpus = [{
-                index: 0,
-                name: summary.cpuModel || 'CPU',
-                memoryGB: Math.max(4, this.toFiniteNumber(summary.effectiveMemory, this.toFiniteNumber(hardware.memory?.total, 16) * 0.7)),
-                speedCoefficient: Math.max(1, this.toFiniteNumber(summary.speedCoefficient, 25))
-            }];
-        }
-
-        gpus.sort((a, b) => {
-            if (b.speedCoefficient !== a.speedCoefficient) return b.speedCoefficient - a.speedCoefficient;
-            return b.memoryGB - a.memoryGB;
-        });
-
-        const reserve = this.toFiniteNumber(reserveGB, this.defaultReserveGB);
-        const reservePerGPU = reserve / Math.max(1, gpus.length);
-        const usableGPUs = gpus.map((gpu) => ({
-            ...gpu,
-            usableMemoryGB: Math.max(1, Math.round((gpu.memoryGB - reservePerGPU) * 100) / 100)
-        }));
-
-        const totalUsableGB = usableGPUs.reduce((sum, gpu) => sum + gpu.usableMemoryGB, 0);
-
-        return {
-            backend,
-            backendName,
-            reserveGB: Math.round(reserve * 100) / 100,
-            isMultiGPU: usableGPUs.length > 1,
-            deviceEnvVar: this.resolveDeviceEnvVar(backend),
-            gpus: usableGPUs,
-            totalUsableGB: Math.round(totalUsableGB * 100) / 100
-        };
-    }
-
-    makeRisk(utilization, fits, strategy) {
-        if (!fits) {
-            return { level: 'critical', score: 95 };
-        }
-
-        const complexityPenalty = strategy === 'spread' ? 12 : strategy === 'replica' ? 6 : 0;
-        const score = Math.min(100, Math.round((utilization * 72) + complexityPenalty));
-
-        let level = 'low';
-        if (score >= 75) level = 'critical';
-        else if (score >= 55) level = 'high';
-        else if (score >= 35) level = 'medium';
-
-        return { level, score };
-    }
-
-    strategyScore(strategyPlan, objective) {
-        const complexityPenalty = strategyPlan.strategy === 'spread'
-            ? (objective === 'latency' ? 12 : 8)
-            : strategyPlan.strategy === 'replica'
-                ? (objective === 'latency' ? 5 : 3)
-                : 0;
-
-        const riskWeight = objective === 'throughput' ? 0.15 : objective === 'latency' ? 0.28 : 0.22;
-        const infeasiblePenalty = strategyPlan.feasible ? 0 : 220;
-
-        return strategyPlan.estimated_tps - (strategyPlan.risk.score * riskWeight) - complexityPenalty - infeasiblePenalty;
-    }
-
-    simulatePin(model, hardwarePlan, contextTokens, targetConcurrency) {
-        const gpu = hardwarePlan.gpus[0];
-        const kvPerRequestGB = this.estimateKVCacheGB(model.paramsB, contextTokens);
-        const totalMemoryGB = model.baseMemoryGB + (kvPerRequestGB * targetConcurrency);
-        const fits = totalMemoryGB <= gpu.usableMemoryGB;
-        const utilization = totalMemoryGB / Math.max(0.1, gpu.usableMemoryGB);
-
-        const baseTPS = this.estimateTokensPerSecond(gpu, model, contextTokens);
-        const throughputPenalty = fits ? 1 : Math.max(0.25, gpu.usableMemoryGB / Math.max(0.1, totalMemoryGB));
-
-        return {
-            strategy: 'pin',
-            feasible: fits,
-            estimated_tps: Math.max(1, Math.round(baseTPS * throughputPenalty)),
-            memory_per_gpu_gb: Math.round(totalMemoryGB * 100) / 100,
-            total_memory_gb: Math.round(totalMemoryGB * 100) / 100,
-            utilization_percent: Math.round(utilization * 100),
-            gpu_count: 1,
-            placement: [{
-                gpu_index: gpu.index,
-                gpu_name: gpu.name,
-                concurrency: targetConcurrency
-            }],
-            device_env_var: hardwarePlan.deviceEnvVar,
-            visible_devices: hardwarePlan.deviceEnvVar ? String(gpu.index) : null,
-            risk: this.makeRisk(utilization, fits, 'pin'),
-            notes: fits
-                ? ['Single-GPU placement keeps routing simple and minimizes scheduling overhead.']
-                : ['Model+context+concurrency exceeds single-GPU memory.']
-        };
-    }
-
-    simulateReplica(model, hardwarePlan, contextTokens, targetConcurrency) {
-        const gpus = hardwarePlan.gpus;
-        const maxReplicas = Math.min(gpus.length, targetConcurrency);
-        const kvPerRequestGB = this.estimateKVCacheGB(model.paramsB, contextTokens);
-
-        let selectedReplicas = 1;
-        let memoryPerReplicaGB = model.baseMemoryGB + (kvPerRequestGB * targetConcurrency);
-        let feasible = false;
-
-        for (let replicas = maxReplicas; replicas >= 1; replicas -= 1) {
-            const perReplicaConcurrency = Math.ceil(targetConcurrency / replicas);
-            const candidateMemory = model.baseMemoryGB + (kvPerRequestGB * perReplicaConcurrency);
-            const candidateGPUs = gpus.slice(0, replicas);
-            const fitsAll = candidateGPUs.every((gpu) => candidateMemory <= gpu.usableMemoryGB);
-            if (fitsAll) {
-                selectedReplicas = replicas;
-                memoryPerReplicaGB = candidateMemory;
-                feasible = true;
-                break;
-            }
-        }
-
-        const chosenGPUs = gpus.slice(0, selectedReplicas);
-        const baseTPS = chosenGPUs.reduce(
-            (sum, gpu) => sum + this.estimateTokensPerSecond(gpu, model, contextTokens),
-            0
-        );
-        const replicaEfficiency = Math.max(0.8, 0.95 - ((selectedReplicas - 1) * 0.02));
-        const estimatedTPS = Math.max(1, Math.round(baseTPS * replicaEfficiency));
-
-        const maxUtilization = chosenGPUs.reduce((max, gpu) => {
-            const util = memoryPerReplicaGB / Math.max(0.1, gpu.usableMemoryGB);
-            return Math.max(max, util);
-        }, 0);
-
-        const placement = [];
-        let remaining = targetConcurrency;
-        for (let i = 0; i < chosenGPUs.length; i += 1) {
-            const gpu = chosenGPUs[i];
-            const slotsLeft = chosenGPUs.length - i;
-            const assigned = Math.ceil(remaining / slotsLeft);
-            placement.push({
-                gpu_index: gpu.index,
-                gpu_name: gpu.name,
-                concurrency: assigned
-            });
-            remaining -= assigned;
-        }
-
-        const visibleDevices = chosenGPUs.map((gpu) => gpu.index).join(',');
-
-        return {
-            strategy: 'replica',
-            feasible,
-            estimated_tps: estimatedTPS,
-            memory_per_gpu_gb: Math.round(memoryPerReplicaGB * 100) / 100,
-            total_memory_gb: Math.round(memoryPerReplicaGB * selectedReplicas * 100) / 100,
-            utilization_percent: Math.round(maxUtilization * 100),
-            gpu_count: selectedReplicas,
-            placement,
-            device_env_var: hardwarePlan.deviceEnvVar,
-            visible_devices: hardwarePlan.deviceEnvVar ? visibleDevices : null,
-            risk: this.makeRisk(maxUtilization, feasible, 'replica'),
-            notes: feasible
-                ? ['Replica strategy scales throughput by running independent model copies per GPU.']
-                : ['No replica count can satisfy per-GPU memory constraints at requested settings.']
-        };
-    }
-
-    simulateSpread(model, hardwarePlan, contextTokens, targetConcurrency) {
-        const gpus = hardwarePlan.gpus;
-        if (gpus.length < 2) {
-            return {
-                strategy: 'spread',
-                feasible: false,
-                estimated_tps: 0,
-                memory_per_gpu_gb: 0,
-                total_memory_gb: 0,
-                utilization_percent: 0,
-                gpu_count: 1,
-                placement: [],
-                device_env_var: hardwarePlan.deviceEnvVar,
-                visible_devices: null,
-                risk: { level: 'critical', score: 100 },
-                notes: ['Tensor/spread placement requires at least two GPUs.']
-            };
-        }
-
-        const kvPerRequestGB = this.estimateKVCacheGB(model.paramsB, contextTokens);
-        const totalMemoryGB = model.baseMemoryGB + (kvPerRequestGB * targetConcurrency);
-
-        let selectedGPUCount = 2;
-        let memoryPerGPU = totalMemoryGB / selectedGPUCount + this.spreadOverheadGB;
-        let feasible = false;
-
-        for (let shardCount = 2; shardCount <= gpus.length; shardCount += 1) {
-            const candidatePerGPU = totalMemoryGB / shardCount + this.spreadOverheadGB;
-            const shardGPUs = gpus.slice(0, shardCount);
-            const fits = shardGPUs.every((gpu) => candidatePerGPU <= gpu.usableMemoryGB);
-            if (fits) {
-                selectedGPUCount = shardCount;
-                memoryPerGPU = candidatePerGPU;
-                feasible = true;
-                break;
-            }
-        }
-
-        if (!feasible) {
-            selectedGPUCount = gpus.length;
-            memoryPerGPU = totalMemoryGB / selectedGPUCount + this.spreadOverheadGB;
-        }
-
-        const chosenGPUs = gpus.slice(0, selectedGPUCount);
-        const primaryTPS = this.estimateTokensPerSecond(chosenGPUs[0], model, contextTokens);
-        const scaleFactor = 1 + (0.55 * (selectedGPUCount - 1));
-        const interconnectPenalty = Math.max(0.65, 1 - (0.07 * (selectedGPUCount - 1)));
-        const estimatedTPS = Math.max(1, Math.round(primaryTPS * scaleFactor * interconnectPenalty));
-
-        const minUsableMemory = chosenGPUs.reduce((min, gpu) => Math.min(min, gpu.usableMemoryGB), Infinity);
-        const utilization = memoryPerGPU / Math.max(0.1, minUsableMemory);
-        const visibleDevices = chosenGPUs.map((gpu) => gpu.index).join(',');
-
-        return {
-            strategy: 'spread',
-            feasible,
-            estimated_tps: estimatedTPS,
-            memory_per_gpu_gb: Math.round(memoryPerGPU * 100) / 100,
-            total_memory_gb: Math.round(memoryPerGPU * selectedGPUCount * 100) / 100,
-            utilization_percent: Math.round(utilization * 100),
-            gpu_count: selectedGPUCount,
-            placement: chosenGPUs.map((gpu) => ({
-                gpu_index: gpu.index,
-                gpu_name: gpu.name,
-                role: 'shard'
-            })),
-            device_env_var: hardwarePlan.deviceEnvVar,
-            visible_devices: hardwarePlan.deviceEnvVar ? visibleDevices : null,
-            risk: this.makeRisk(utilization, feasible, 'spread'),
-            notes: feasible
-                ? ['Spread strategy shards one model across multiple GPUs and favors capacity over simplicity.']
-                : ['Even full spread cannot fit requested settings within per-GPU memory limits.']
-        };
-    }
-
-    pickRecommendedStrategy(strategies, objective) {
-        const scored = strategies.map((plan) => ({
-            ...plan,
-            objective_score: Math.round(this.strategyScore(plan, objective) * 100) / 100
-        }));
-
-        scored.sort((a, b) => b.objective_score - a.objective_score);
-        return scored[0];
-    }
-
-    buildNotes(hardwarePlan, modelPlans) {
-        const notes = [];
-        if (!hardwarePlan.isMultiGPU) {
-            notes.push('Detected single-GPU (or CPU-only) runtime; replica/spread strategies may not be feasible.');
-        }
-
-        const infeasibleCount = modelPlans.filter((model) => !model.recommended?.feasible).length;
-        if (infeasibleCount > 0) {
-            notes.push(`${infeasibleCount} model(s) exceed safe memory at requested ctx/concurrency. Lower --ctx or --concurrency.`);
-        }
-
-        if (!hardwarePlan.deviceEnvVar) {
-            notes.push('Backend does not expose a standard GPU visibility env var; use strategy output as conceptual placement guidance.');
-        }
-
-        return notes;
-    }
-
-    plan({
-        hardware,
-        models,
-        targetContext = 8192,
-        targetConcurrency = 2,
-        objective = 'balanced',
-        reserveGB = null
-    }) {
-        const normalizedModels = this.normalizeModels(models);
-        if (!normalizedModels.length) {
-            throw new Error('At least one model is required for GPU planning.');
-        }
-
-        const normalizedObjective = this.normalizeObjective(objective);
-        const contextTokens = this.clamp(
-            Math.round(this.toFiniteNumber(targetContext, 8192)),
-            512,
-            131072
-        );
-        const concurrency = this.clamp(
-            Math.round(this.toFiniteNumber(targetConcurrency, 2)),
-            1,
-            64
-        );
-
-        const hardwarePlan = this.resolveHardware(hardware, reserveGB);
-
-        const modelPlans = normalizedModels.map((model) => {
-            const strategies = [
-                this.simulatePin(model, hardwarePlan, contextTokens, concurrency),
-                this.simulateReplica(model, hardwarePlan, contextTokens, concurrency),
-                this.simulateSpread(model, hardwarePlan, contextTokens, concurrency)
-            ];
-
-            const recommended = this.pickRecommendedStrategy(strategies, normalizedObjective);
-
-            return {
-                name: model.name,
-                size: model.size,
-                file_size_gb: model.fileSizeGB,
-                params_b: model.paramsB,
-                quantization: this.normalizeQuantization(model.quantization),
-                estimated_base_memory_gb: model.baseMemoryGB,
-                recommended,
-                strategies
-            };
-        });
-
-        return {
-            objective: normalizedObjective,
-            inputs: {
-                target_context: contextTokens,
-                target_concurrency: concurrency
-            },
-            hardware: {
-                backend: hardwarePlan.backend,
-                backend_name: hardwarePlan.backendName,
-                is_multi_gpu: hardwarePlan.isMultiGPU,
-                gpu_count: hardwarePlan.gpus.length,
-                reserve_gb: hardwarePlan.reserveGB,
-                total_usable_memory_gb: hardwarePlan.totalUsableGB,
-                device_env_var: hardwarePlan.deviceEnvVar,
-                gpus: hardwarePlan.gpus.map((gpu) => ({
-                    index: gpu.index,
-                    name: gpu.name,
-                    memory_gb: gpu.memoryGB,
-                    usable_memory_gb: gpu.usableMemoryGB,
-                    speed_coefficient: gpu.speedCoefficient
-                }))
-            },
-            models: modelPlans,
-            notes: this.buildNotes(hardwarePlan, modelPlans)
-        };
-    }
-}
-
-module.exports = OllamaGPUPlacementPlanner;