llm-checker 3.5.8 → 3.5.10

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.8",
+  version: "3.5.10",
 });
 
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.8",
+  "version": "3.5.10",
   "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/models/ai-check-selector.js

@@ -7,15 +7,16 @@
 
 const DeterministicModelSelector = require('./deterministic-selector');
 const { OllamaNativeScraper } = require('../ollama/native-scraper');
+const OllamaClient = require('../ollama/client');
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
-const fetch = require('../utils/fetch');
 const { evaluateFineTuningSupport } = require('./fine-tuning-support');
 
 class AICheckSelector {
     constructor() {
         this.deterministicSelector = new DeterministicModelSelector();
+        this.ollamaClient = new OllamaClient();
         this.ollamaScraper = new OllamaNativeScraper();
         this.cachePath = path.join(require('os').homedir(), '.llm-checker', 'ai-check-cache.json');
         
@@ -389,17 +390,10 @@ Return JSON with this structure:
             ]
         };
 
-        const response = await fetch('http://localhost:11434/api/chat', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(requestBody)
+        const data = await this.ollamaClient.chat(modelId, requestBody.messages, {
+            timeoutMs: 45000,
+            generationOptions: requestBody.options
         });
-
-        if (!response.ok) {
-            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
-        }
-
-        const data = await response.json();
         
         if (!data.message || !data.message.content) {
             throw new Error(`Invalid response from Ollama API: ${JSON.stringify(data)}`);

package/src/models/deterministic-selector.js

@@ -9,7 +9,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { spawn } = require('child_process');
-const fetch = require('../utils/fetch');
+const OllamaClient = require('../ollama/client');
 const { DETERMINISTIC_WEIGHTS } = require('./scoring-config');
 const {
     parseBillionsValue: parseMoEBillionsValue,
@@ -24,6 +24,7 @@ class DeterministicModelSelector {
     constructor() {
         this.catalogPath = path.join(__dirname, 'catalog.json');
         this.benchCachePath = path.join(os.homedir(), '.llm-checker', 'bench.json');
+        this.ollamaClient = new OllamaClient();
         this.ollamaCachePaths = [
             path.join(os.homedir(), '.llm-checker', 'cache', 'ollama', 'ollama-detailed-models.json'),
             path.join(__dirname, '../ollama/.cache/ollama-detailed-models.json')
@@ -2018,33 +2019,23 @@ class DeterministicModelSelector {
         
         const prompt = prompts[category] || prompts['general'];
         const targetTokens = 128;
-        
-        const startTime = Date.now();
-        
-        // Make HTTP request to Ollama API
-        const response = await fetch('http://localhost:11434/api/generate', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                model: modelId,
-                prompt: prompt,
-                stream: false,
-                options: {
-                    num_predict: targetTokens
-                }
-            })
+
+        const result = await this.ollamaClient.generate(modelId, prompt, {
+            generationOptions: {
+                num_predict: targetTokens
+            }
         });
-        
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+
+        if (Number.isFinite(result.tokensPerSecond) && result.tokensPerSecond > 0) {
+            return result.tokensPerSecond;
         }
-        
-        const result = await response.json();
-        const elapsedSeconds = (Date.now() - startTime) / 1000;
-        
-        // Estimate tokens generated (simplified)
-        const tokensGenerated = result.response ? result.response.split(' ').length * 1.3 : targetTokens;
-        
+
+        const elapsedSeconds = Math.max(0.001, Number(result.responseTime || 0) / 1000);
+        const estimatedResponseTokens = result.response
+            ? result.response.split(/\s+/).filter(Boolean).length * 1.3
+            : targetTokens;
+        const tokensGenerated = Number(result.eval_count) || estimatedResponseTokens;
+
         return tokensGenerated / elapsedSeconds;
     }
 

package/src/ollama/client.js

@@ -3,9 +3,9 @@ const fetch = require('../utils/fetch');
 class OllamaClient {
     constructor(baseURL = null) {
         // Support OLLAMA_HOST environment variable (standard Ollama configuration)
-        // Also support OLLAMA_URL for backwards compatibility
+        // Also support OLLAMA_BASE_URL and OLLAMA_URL for backwards compatibility
         this.preferredBaseURL = this.normalizeBaseURL(
-            baseURL || process.env.OLLAMA_HOST || process.env.OLLAMA_URL || 'http://localhost:11434'
+            baseURL || process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || process.env.OLLAMA_URL || 'http://localhost:11434'
         );
         this.baseURL = this.preferredBaseURL;
 
@@ -35,7 +35,8 @@ class OllamaClient {
                 candidates.push(ipv4.toString().replace(/\/$/, ''));
 
                 const ipv6 = new URL(parsed.toString());
-                ipv6.hostname = '::1';
+                // URL.hostname expects bracketed IPv6 literals when mutating an existing URL.
+                ipv6.hostname = '[::1]';
                 candidates.push(ipv6.toString().replace(/\/$/, ''));
             }
         } catch (error) {
@@ -473,51 +474,86 @@ class OllamaClient {
         };
     }
 
-    async testModelPerformance(modelName, testPrompt = "Hello, how are you?") {
+    async generate(modelName, prompt, options = {}) {
         const availability = await this.checkOllamaAvailability();
         if (!availability.available) {
             throw new Error(`Ollama not available: ${availability.error}`);
         }
 
+        const {
+            timeoutMs = 30000,
+            stream = false,
+            keepAlive,
+            format,
+            generationOptions = {}
+        } = options;
+
+        const payload = {
+            model: modelName,
+            prompt,
+            stream: Boolean(stream)
+        };
+
+        if (keepAlive) payload.keep_alive = keepAlive;
+        if (format) payload.format = format;
+        if (generationOptions && Object.keys(generationOptions).length > 0) {
+            payload.options = generationOptions;
+        }
+
         const startTime = Date.now();
 
         try {
             const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 30000);
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
 
             const response = await fetch(`${this.baseURL}/api/generate`, {
                 method: 'POST',
                 signal: controller.signal,
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    model: modelName,
-                    prompt: testPrompt,
-                    stream: false,
-                    options: {
-                        num_predict: 50 // Limitar respuesta para test rápido
-                    }
-                })
+                body: JSON.stringify(payload)
             });
 
             clearTimeout(timeoutId);
 
             if (!response.ok) {
-                throw new Error(`Test failed: HTTP ${response.status}`);
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
             }
 
             const data = await response.json();
-            const endTime = Date.now();
+            const responseTime = Date.now() - startTime;
+            const speed = this.calculateTokensPerSecond(data, responseTime);
 
-            const totalTime = endTime - startTime;
+            return {
+                ...data,
+                responseTime,
+                tokensPerSecond: speed.tokensPerSecond,
+                evalTokensPerSecond: speed.evalTokensPerSecond,
+                endToEndTokensPerSecond: speed.endToEndTokensPerSecond
+            };
+        } catch (error) {
+            throw new Error(`Failed to run generate request: ${error.message}`);
+        }
+    }
+
+    async testModelPerformance(modelName, testPrompt = "Hello, how are you?") {
+        const startTime = Date.now();
+
+        try {
+            const data = await this.generate(modelName, testPrompt, {
+                timeoutMs: 30000,
+                generationOptions: {
+                    num_predict: 50
+                }
+            });
             const tokensGenerated = Number(data.eval_count) || 0;
-            const speed = this.calculateTokensPerSecond(data, totalTime);
 
             return {
                 success: true,
-                responseTime: totalTime,
-                tokensPerSecond: speed.tokensPerSecond,
-                evalTokensPerSecond: speed.evalTokensPerSecond,
-                endToEndTokensPerSecond: speed.endToEndTokensPerSecond,
+                responseTime: data.responseTime,
+                tokensPerSecond: data.tokensPerSecond,
+                evalTokensPerSecond: data.evalTokensPerSecond,
+                endToEndTokensPerSecond: data.endToEndTokensPerSecond,
                 tokensGenerated,
                 loadTime: data.load_duration ? Math.round(data.load_duration / 1000000) : null,
                 evalTime: data.eval_duration ? Math.round(data.eval_duration / 1000000) : null,

package/src/utils/config.js

@@ -16,7 +16,7 @@ class ConfigManager {
         return {
             version: "2.0",
             ollama: {
-                baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434",
+                baseURL: process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434",
                 timeout: 30000,
                 enabled: true,
                 autoDetect: true,
@@ -176,7 +176,9 @@ class ConfigManager {
         }
 
         // Ollama overrides
-        if (process.env.OLLAMA_BASE_URL) {
+        if (process.env.OLLAMA_HOST) {
+            this.config.ollama.baseURL = process.env.OLLAMA_HOST;
+        } else if (process.env.OLLAMA_BASE_URL) {
             this.config.ollama.baseURL = process.env.OLLAMA_BASE_URL;
         }
 
@@ -356,4 +358,4 @@ class ConfigManager {
     }
 }
 
-module.exports = ConfigManager;
+module.exports = ConfigManager;